From d91d77633d321d50359082cd0b144f8da6235a20 Mon Sep 17 00:00:00 2001 From: Yingjie Wang Date: Tue, 29 Aug 2017 09:59:39 +0800 Subject: [PATCH 1/8] KW issues for agps module Check for null pointer before dereference in Agps.cpp Change-Id: Idd1e7950572c8a45e5c7d7da0f5caee35583b53c CRs-Fixed: 2100353 --- gnss/Agps.cpp | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/gnss/Agps.cpp b/gnss/Agps.cpp index 436351cd..ace639b9 100644 --- a/gnss/Agps.cpp +++ b/gnss/Agps.cpp @@ -462,9 +462,11 @@ void AgpsStateMachine::setAPN(char* apn, unsigned int len){ if (NULL != apn) { mAPN = new char[len+1]; - memcpy(mAPN, apn, len); - mAPN[len] = '\0'; - mAPNLen = len; + if (NULL != mAPN) { + memcpy(mAPN, apn, len); + mAPN[len] = '\0'; + mAPNLen = len; + } } } From 2a9654103b32b86b0894f21505ddb522aa829da9 Mon Sep 17 00:00:00 2001 From: Srivastava Date: Tue, 21 Feb 2017 00:59:46 +0530 Subject: [PATCH 2/8] Integrating AGPS call flow with LocNetIface Using LocNetIface AGPS capability in case client doesn't provide status callback to setup data call. Also adding below APN and IP Type config parameters to gps.conf : INTERNET_APN INTERNET_IP_TYPE SUPL_APN SUPL_IP_TYPE CRs-Fixed: 2005565 Change-Id: If52963ed50625db379c958586813850746eb2c4e --- etc/gps.conf | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/etc/gps.conf b/etc/gps.conf index 1027d76b..d30461e6 100644 --- a/etc/gps.conf +++ b/etc/gps.conf @@ -205,3 +205,17 @@ MISSING_PULSE_TIME_DELTA = 900 # This settings enables time uncertainty propagation # logic incase of missing PPS pulse PROPAGATION_TIME_UNCERTAINTY = 1 + +####################################### +# APN / IP Type Configuration +# APN and IP Type to use for setting +# up WWAN call. +# Use below values for IP Type: +# v4 = 4 +# v6 = 6 +# v4v6 = 10 +####################################### +# INTERNET_APN = abc.xyz +# INTERNET_IP_TYPE = 4 +# SUPL_APN = abc.xyz +# SUPL_IP_TYPE = 4 From cd3027e3a646612e77d0d0026393e38404f53deb Mon Sep 17 00:00:00 2001 From: Yingjie Wang Date: Tue, 22 Aug 2017 09:41:23 +0800 Subject: [PATCH 3/8] Filter the configs sent to modem on change basis Filter setServer, setPositionMode and startTracking commands sent to modem unless change happens and optimize out modem traffic hence. Change-Id: I389af9c11784848045d2d3d5d3c799675a4b24be CRs-Fixed: 2093253 --- gnss/GnssAdapter.cpp | 40 ++++++++++++++++++++++++++-------------- gnss/GnssAdapter.h | 7 +++++-- 2 files changed, 31 insertions(+), 16 deletions(-) diff --git a/gnss/GnssAdapter.cpp b/gnss/GnssAdapter.cpp index edbb0933..d4ffcb25 100644 --- a/gnss/GnssAdapter.cpp +++ b/gnss/GnssAdapter.cpp @@ -44,9 +44,7 @@ #include #include -#include #include -#include #define RAD2DEG (180.0 / M_PI) @@ -68,7 +66,8 @@ GnssAdapter::GnssAdapter() : mNiData(), mAgpsManager(), mAgpsCbInfo(), - mSystemStatus(SystemStatus::getInstance(mMsgTask)) + mSystemStatus(SystemStatus::getInstance(mMsgTask)), + mServerUrl("") { LOC_LOGD("%s]: Constructor %p", __func__, this); mUlpPositionMode.mode = LOC_POSITION_MODE_INVALID; @@ -636,8 +635,6 @@ GnssAdapter::gnssUpdateConfigCommand(GnssConfig config) delete[] mIds; } inline virtual void proc() const { - //const size_t MAX_BITS_COUNT = 10; - //LocationError errs[MAX_BITS_COUNT] = {}; LocationError* errs = new LocationError[mCount]; LocationError err = LOCATION_ERROR_SUCCESS; uint32_t index = 0; @@ -669,30 +666,33 @@ GnssAdapter::gnssUpdateConfigCommand(GnssConfig config) if (GNSS_ASSISTANCE_TYPE_SUPL == mConfig.assistanceServer.type) { if (ContextBase::mGps_conf.AGPS_CONFIG_INJECT) { char serverUrl[MAX_URL_LEN] = {}; - uint32_t length = 0; + int32_t length = 0; const char noHost[] = "NONE"; if (NULL == mConfig.assistanceServer.hostName || strncasecmp(noHost, mConfig.assistanceServer.hostName, sizeof(noHost)) == 0) { + err = LOCATION_ERROR_INVALID_PARAMETER; } else { length = snprintf(serverUrl, sizeof(serverUrl), "%s:%u", mConfig.assistanceServer.hostName, mConfig.assistanceServer.port); } - if (sizeof(serverUrl) > length) { + if (length > 0 && strncasecmp(mAdapter.getServerUrl().c_str(), + serverUrl, sizeof(serverUrl)) != 0) { + mAdapter.setServerUrl(serverUrl); err = mApi.setServer(serverUrl, length); - } else { - err = LOCATION_ERROR_INVALID_PARAMETER; } + } else { err = LOCATION_ERROR_SUCCESS; } } else if (GNSS_ASSISTANCE_TYPE_C2K == mConfig.assistanceServer.type) { if (ContextBase::mGps_conf.AGPS_CONFIG_INJECT) { struct in_addr addr; - if (!mAdapter.resolveInAddress(mConfig.assistanceServer.hostName, &addr)) { + if (!mAdapter.resolveInAddress(mConfig.assistanceServer.hostName, + &addr)) { LOC_LOGE("%s]: hostName %s cannot be resolved", __func__, mConfig.assistanceServer.hostName); err = LOCATION_ERROR_INVALID_PARAMETER; @@ -1246,6 +1246,15 @@ GnssAdapter::eraseTrackingSession(LocationAPI* client, uint32_t sessionId) } +bool GnssAdapter::setUlpPositionMode(const LocPosMode& mode) { + if (!mUlpPositionMode.equals(mode)) { + mUlpPositionMode = mode; + return true; + } else { + return false; + } +} + void GnssAdapter::reportResponse(LocationAPI* client, LocationError err, uint32_t sessionId) { @@ -1411,8 +1420,9 @@ GnssAdapter::setPositionModeCommand(LocPosMode& locPosMode) mLocPosMode(locPosMode) {} inline virtual void proc() const { // saves the mode in adapter to be used when startTrackingCommand is called from ULP - mAdapter.setUlpPositionMode(mLocPosMode); - mApi.setPositionMode(mLocPosMode); + if (mAdapter.setUlpPositionMode(mLocPosMode)) { + mApi.setPositionMode(mLocPosMode); + } } }; @@ -1435,8 +1445,10 @@ GnssAdapter::startTrackingCommand() inline virtual void proc() const { // we get this call from ULP, so just call LocApi without multiplexing because // ulp would be doing the multiplexing for us if it is present - LocPosMode& ulpPositionMode = mAdapter.getUlpPositionMode(); - mApi.startFix(ulpPositionMode); + if (!mAdapter.isInSession()) { + LocPosMode& ulpPositionMode = mAdapter.getUlpPositionMode(); + mApi.startFix(ulpPositionMode); + } } }; diff --git a/gnss/GnssAdapter.h b/gnss/GnssAdapter.h index 46ba34fd..3cb2c64b 100644 --- a/gnss/GnssAdapter.h +++ b/gnss/GnssAdapter.h @@ -110,6 +110,7 @@ class GnssAdapter : public LocAdapterBase { /* === SystemStatus ===================================================================== */ SystemStatus* mSystemStatus; + std::string mServerUrl; /*==== CONVERSION ===================================================================*/ static void convertOptions(LocPosMode& out, const LocationOptions& options); @@ -170,7 +171,7 @@ public: void saveTrackingSession(LocationAPI* client, uint32_t sessionId, const LocationOptions& options); void eraseTrackingSession(LocationAPI* client, uint32_t sessionId); - void setUlpPositionMode(const LocPosMode& mode) { mUlpPositionMode = mode; } + bool setUlpPositionMode(const LocPosMode& mode); LocPosMode& getUlpPositionMode() { return mUlpPositionMode; } LocationError startTrackingMultiplex(const LocationOptions& options); LocationError startTracking(const LocationOptions& options); @@ -215,7 +216,7 @@ public: void setPowerVoteId(uint32_t id) { mPowerVoteId = id; } uint32_t getPowerVoteId() { return mPowerVoteId; } bool resolveInAddress(const char* hostAddress, struct in_addr* inAddress); - + virtual bool isInSession() { return !mTrackingSessions.empty(); } /* ==== REPORTS ======================================================================== */ /* ======== EVENTS ====(Called from QMI/ULP Thread)===================================== */ virtual void reportPositionEvent(const UlpLocation& ulpLocation, @@ -254,6 +255,8 @@ public: /*==== SYSTEM STATUS ================================================================*/ inline SystemStatus* getSystemStatus(void) { return mSystemStatus; } + std::string& getServerUrl(void) { return mServerUrl; } + void setServerUrl(const char* server) { mServerUrl.assign(server); } /*==== CONVERSION ===================================================================*/ static uint32_t convertGpsLock(const GnssConfigGpsLock gpsLock); From e0f49cdede64d24e0063c8d20b8e2af7a87721b6 Mon Sep 17 00:00:00 2001 From: Baili Feng Date: Tue, 5 Sep 2017 11:59:34 +0800 Subject: [PATCH 4/8] Check status before decide report position or not Check if inaccuracy exceeds our tolerance only when status is LOC_POS_TECH_MASK_SATELLITE Change-Id: If45f2d8f5347f5b8a7df944dfa5b8071f6c2380a CRs-Fixed: 2104827 --- gnss/GnssAdapter.cpp | 52 ++++++++++++++++++++++++-------------------- gnss/GnssAdapter.h | 2 ++ 2 files changed, 31 insertions(+), 23 deletions(-) diff --git a/gnss/GnssAdapter.cpp b/gnss/GnssAdapter.cpp index edbb0933..df7ea354 100644 --- a/gnss/GnssAdapter.cpp +++ b/gnss/GnssAdapter.cpp @@ -1922,34 +1922,41 @@ GnssAdapter::reportPositionEvent(const UlpLocation& ulpLocation, sendMsg(new MsgReportPosition(*this, ulpLocation, locationExtended, status, techMask)); } +bool +GnssAdapter::needReport(const UlpLocation& ulpLocation, + enum loc_sess_status status, + LocPosTechMask techMask) { + bool reported = false; + if (LOC_SESS_SUCCESS == status) { + // this is a final fix + LocPosTechMask mask = + LOC_POS_TECH_MASK_SATELLITE | LOC_POS_TECH_MASK_SENSORS | LOC_POS_TECH_MASK_HYBRID; + // it is a Satellite fix or a sensor fix + reported = (mask & techMask); + } else if (LOC_SESS_INTERMEDIATE == status && + LOC_SESS_INTERMEDIATE == ContextBase::mGps_conf.INTERMEDIATE_POS) { + // this is a intermediate fix and we accepte intermediate + + // it is NOT the case that + // there is inaccuracy; and + // we care about inaccuracy; and + // the inaccuracy exceeds our tolerance + reported = !((ulpLocation.gpsLocation.flags & LOC_GPS_LOCATION_HAS_ACCURACY) && + (ContextBase::mGps_conf.ACCURACY_THRES != 0) && + (ulpLocation.gpsLocation.accuracy > ContextBase::mGps_conf.ACCURACY_THRES)); + } + + return reported; +} + void GnssAdapter::reportPosition(const UlpLocation& ulpLocation, const GpsLocationExtended& locationExtended, enum loc_sess_status status, LocPosTechMask techMask) { - bool reported = false; - // what's in the if is... (line by line) - // 1. this is a final fix; and - // 1.1 it is a Satellite fix; or - // 1.2 it is a sensor fix - // 2. (must be intermediate fix... implicit) - // 2.1 we accepte intermediate; and - // 2.2 it is NOT the case that - // 2.2.1 there is inaccuracy; and - // 2.2.2 we care about inaccuracy; and - // 2.2.3 the inaccuracy exceeds our tolerance - if ((LOC_SESS_SUCCESS == status && - ((LOC_POS_TECH_MASK_SATELLITE | - LOC_POS_TECH_MASK_SENSORS | - LOC_POS_TECH_MASK_HYBRID) & - techMask)) || - (LOC_SESS_INTERMEDIATE == ContextBase::mGps_conf.INTERMEDIATE_POS && - !((ulpLocation.gpsLocation.flags & - LOC_GPS_LOCATION_HAS_ACCURACY) && - (ContextBase::mGps_conf.ACCURACY_THRES != 0) && - (ulpLocation.gpsLocation.accuracy > - ContextBase::mGps_conf.ACCURACY_THRES)))) { + bool reported = needReport(ulpLocation, status, techMask); + if (reported) { if (locationExtended.flags & GPS_LOCATION_EXTENDED_HAS_GNSS_SV_USED_DATA) { mGnssSvIdUsedInPosAvail = true; mGnssSvIdUsedInPosition = locationExtended.gnss_sv_used_ids; @@ -1966,7 +1973,6 @@ GnssAdapter::reportPosition(const UlpLocation& ulpLocation, it->second.gnssLocationInfoCb(locationInfo); } } - reported = true; } if (NMEA_PROVIDER_AP == ContextBase::mGps_conf.NMEA_PROVIDER && !mTrackingSessions.empty()) { diff --git a/gnss/GnssAdapter.h b/gnss/GnssAdapter.h index 46ba34fd..08207a42 100644 --- a/gnss/GnssAdapter.h +++ b/gnss/GnssAdapter.h @@ -238,6 +238,8 @@ public: virtual bool reportDataCallClosed(); /* ======== UTILITIES ================================================================= */ + bool needReport(const UlpLocation& ulpLocation, + enum loc_sess_status status, LocPosTechMask techMask); void reportPosition(const UlpLocation &ulpLocation, const GpsLocationExtended &locationExtended, enum loc_sess_status status, From ff8b31761cff3098444c41c8daa7baa6dff92ccd Mon Sep 17 00:00:00 2001 From: Harikrishnan Hariharan Date: Fri, 11 Aug 2017 17:36:10 +0530 Subject: [PATCH 5/8] Integrate XtraSysStatObs with SystemStatusObserver Use SystemStatusObserver to subscribe for dataitems in XtraSystemStatusObserver. Change-Id: Ib1828b9025c9c5bb5194a36014249472ed3f6f9e CRs-Fixed: 2093290 --- core/SystemStatus.cpp | 74 ++- core/SystemStatus.h | 182 ++++++ core/SystemStatusOsObserver.cpp | 1007 ++++++++++++++--------------- core/SystemStatusOsObserver.h | 292 ++------- gnss/GnssAdapter.cpp | 3 +- gnss/GnssAdapter.h | 6 +- gnss/XtraSystemStatusObserver.cpp | 121 +++- gnss/XtraSystemStatusObserver.h | 31 +- gnss/location_gnss.cpp | 2 +- 9 files changed, 921 insertions(+), 797 deletions(-) diff --git a/core/SystemStatus.cpp b/core/SystemStatus.cpp index dc036048..52d28c7a 100644 --- a/core/SystemStatus.cpp +++ b/core/SystemStatus.cpp @@ -37,6 +37,7 @@ #include #include #include +#include #include #include @@ -1212,7 +1213,8 @@ IOsObserver* SystemStatus::getOsObserver() } SystemStatus::SystemStatus(const MsgTask* msgTask) : - mSysStatusObsvr(msgTask) + mSysStatusObsvr(msgTask), + mConnected(false) { int result = 0; ENTRY_LOG (); @@ -1413,6 +1415,28 @@ bool SystemStatus::setPositionFailure(const SystemStatusPQWS1& nmea) return true; } +/****************************************************************************** + SystemStatus - storing dataitems +******************************************************************************/ +bool SystemStatus::setNetworkInfo(IDataItemCore* dataitem) +{ + SystemStatusNetworkInfo* data = reinterpret_cast(dataitem); + SystemStatusNetworkInfo s(data->mType,data->mTypeName,data->mSubTypeName, + data->mAvailable,data->mConnected,data->mRoaming); + s.dump(); + mConnected = data->mConnected; + + 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()); + } + } + return true; +} + /****************************************************************************** @brief API to set report data into internal buffer @@ -1533,6 +1557,26 @@ bool SystemStatus::eventPosition(const UlpLocation& location, return true; } +/****************************************************************************** +@brief API to set report DataItem event into internal buffer + +@param[In] DataItem + +@return true when successfully done +******************************************************************************/ +bool SystemStatus::eventDataItemNotify(IDataItemCore* dataitem) +{ + pthread_mutex_lock(&mMutexSystemStatus); + switch(dataitem->getId()) + { + case NETWORKINFO_DATA_ITEM_ID: + setNetworkInfo(dataitem); + break; + } + pthread_mutex_unlock(&mMutexSystemStatus); + return true; +} + /****************************************************************************** @brief API to get report data into a given buffer @@ -1712,5 +1756,33 @@ bool SystemStatus::setDefaultReport(void) return true; } +/****************************************************************************** +@brief API to handle connection status update event from GnssRil + +@param[In] Connection status + +@return true when successfully done +******************************************************************************/ +bool SystemStatus::eventConnectionStatus(bool connected, uint8_t type) +{ + if (connected != mConnected) { + mConnected = connected; + + // 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); + mSysStatusObsvr.notify(dl); + } + return true; +} + } // namespace loc_core diff --git a/core/SystemStatus.h b/core/SystemStatus.h index 8cf75b5c..5dc2d9ff 100644 --- a/core/SystemStatus.h +++ b/core/SystemStatus.h @@ -34,6 +34,7 @@ #include #include #include +#include #include #include @@ -367,19 +368,183 @@ public: 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(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(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(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(src); + mValue = mccmnc->mValue; + if (dataItemCopied) { + *dataItemCopied = true; + } + return 1; + } +}; + /****************************************************************************** SystemStatusReports ******************************************************************************/ class SystemStatusReports { public: + // from QMI_LOC indication std::vector mLocation; + // from ME debug NMEA std::vector mTimeAndClock; std::vector mXoState; std::vector mRfAndParams; std::vector mErrRecovery; + // from PE debug NMEA std::vector mInjectedPosition; std::vector mBestPosition; std::vector mXtra; @@ -388,7 +553,14 @@ public: std::vector mPdr; std::vector mNavData; + // from SM debug NMEA std::vector mPositionFailure; + + // from dataitems observer + std::vector mGpsState; + std::vector mNetworkInfo; + std::vector mTac; + std::vector mMccMnc; }; /****************************************************************************** @@ -424,7 +596,13 @@ private: 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); @@ -443,6 +621,8 @@ private: bool setPositionFailure(const SystemStatusPQWS1& nmea); + bool setNetworkInfo(IDataItemCore* dataitem); + public: // Static methods static SystemStatus* getInstance(const MsgTask* msgTask); @@ -451,9 +631,11 @@ public: // 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 diff --git a/core/SystemStatusOsObserver.cpp b/core/SystemStatusOsObserver.cpp index e327f93a..319f1d7a 100644 --- a/core/SystemStatusOsObserver.cpp +++ b/core/SystemStatusOsObserver.cpp @@ -28,618 +28,565 @@ */ #define LOG_TAG "LocSvc_SystemStatusOsObserver" -#include -#include -#include -#include -#include -#include -#include #include - -#include +#include #include - -#include #include #include #include #include - #include -#include - namespace loc_core { -#define BREAK_IF_ZERO(ERR,X) if(0==(X)) {result = (ERR); break;} -#define BREAK_IF_NON_ZERO(ERR,X) if(0!=(X)) {result = (ERR); break;} - SystemStatusOsObserver::SystemStatusOsObserver(const MsgTask* msgTask) : - mAddress ("SystemStatusOsObserver"), - mClientIndex(IndexFactory :: createClientIndex ()), - mDataItemIndex(IndexFactory :: createDataItemIndex ()) + mAddress("SystemStatusOsObserver"), + mClientIndex(IndexFactory :: createClientIndex()), + mDataItemIndex(IndexFactory :: createDataItemIndex()) { - int result = -1; - ENTRY_LOG (); - do { - BREAK_IF_ZERO (1, mClientIndex); - BREAK_IF_ZERO (2, mDataItemIndex); - mContext.mMsgTask = msgTask; - result = 0; - } while (0); - EXIT_LOG_WITH_ERROR ("%d",result); + mContext.mMsgTask = msgTask; } -SystemStatusOsObserver :: ~SystemStatusOsObserver () +SystemStatusOsObserver::~SystemStatusOsObserver() { // Close data-item library handle DataItemsFactoryProxy::closeDataItemLibraryHandle(); // Destroy cache - map :: iterator citer = mDataItemCache.begin (); - for (; citer != mDataItemCache.end (); ++citer) { - if (citer->second != NULL) { delete citer->second; } + for (auto each : mDataItemCache) { + if (nullptr != each.second) { + delete each.second; + } } - mDataItemCache.clear (); + + mDataItemCache.clear(); delete mClientIndex; delete mDataItemIndex; - mClientIndex = NULL; - mDataItemIndex = NULL; } -/****************************************************************************** - Message proc -******************************************************************************/ -void SystemStatusOsObserver :: HandleSubscribeReq :: proc () const { +void SystemStatusOsObserver::setSubscriptionObj(IDataItemSubscription* subscriptionObj) +{ + mContext.mSubscriptionObj = subscriptionObj; - int result = 0; - ENTRY_LOG (); - do { - if (mDataItemList.empty ()) { - LOC_LOGV("mDataItemList is empty. Nothing to do. Exiting"); - result = 0; - break; - } - //mDataItemList.sort (); - // Handle First Response - list pendingFirstResponseList; - this->mParent->mClientIndex->add (this->mClient, mDataItemList, pendingFirstResponseList); + LOC_LOGD("Request cache size - Subscribe:%zu RequestData:%zu", + mSubscribeReqCache.size(), mReqDataCache.size()); - // Do not send first response for only pendingFirstResponseList, - // instead send for all the data items (present in the cache) that - // have been subscribed for each time. - this->mParent->sendFirstResponse (mDataItemList, this->mClient); - - list yetToSubscribeDataItemsList; - this->mParent->mDataItemIndex->add (this->mClient, mDataItemList, yetToSubscribeDataItemsList); - // Send subscription list to framework - if (!yetToSubscribeDataItemsList.empty ()) { - this->mParent->mContext.mSubscriptionObj->subscribe - ( - yetToSubscribeDataItemsList, - this->mParent - ); - LOC_LOGD ("Subscribe Request sent to framework for the following data items"); - this->mParent->logMe (yetToSubscribeDataItemsList); - } - - } while (0); - EXIT_LOG_WITH_ERROR ("%d", result); - return; + // we have received the subscription object. process cached requests + // process - subscribe request cache + for (auto each : mSubscribeReqCache) { + subscribe(each.second, each.first); + } + // process - requestData request cache + for (auto each : mReqDataCache) { + requestData(each.second, each.first); + } } -void SystemStatusOsObserver :: HandleUpdateSubscriptionReq :: proc () const { - int result = 0; - ENTRY_LOG (); - do { - if (mDataItemList.empty ()) { - LOC_LOGV("mDataItemList is empty. Nothing to do. Exiting"); - result = 0; - break; +// Helper to cache requests subscribe and requestData till subscription obj is obtained +void SystemStatusOsObserver::cacheObserverRequest(ObserverReqCache& reqCache, + const list& l, IDataItemObserver* client) +{ + ObserverReqCache::iterator dicIter = reqCache.find(client); + if (dicIter != reqCache.end()) { + // found + list difference(0); + set_difference(l.begin(), l.end(), + dicIter->second.begin(), dicIter->second.end(), + inserter(difference, difference.begin())); + if (!difference.empty()) { + difference.sort(); + dicIter->second.merge(difference); + dicIter->second.unique(); } - //mDataItemList.sort (); - list currentlySubscribedList; - this->mParent->mClientIndex->getSubscribedList (this->mClient, currentlySubscribedList); - list removeDataItemList; - set_difference (currentlySubscribedList.begin (), currentlySubscribedList.end (), - mDataItemList.begin (), mDataItemList.end (), - inserter (removeDataItemList,removeDataItemList.begin ())); - // Handle First Response - list pendingFirstResponseList; - this->mParent->mClientIndex->add (this->mClient, mDataItemList, pendingFirstResponseList); - // Send First Response - this->mParent->sendFirstResponse (pendingFirstResponseList, this->mClient); - - list yetToSubscribeDataItemsList; - this->mParent->mDataItemIndex->add (this->mClient, mDataItemList, yetToSubscribeDataItemsList); - // Send subscription list to framework - if (!yetToSubscribeDataItemsList.empty ()) { - this->mParent->mContext.mSubscriptionObj->subscribe - ( - yetToSubscribeDataItemsList, - this->mParent - ); - LOC_LOGD ("Subscribe Request sent to framework for the following data items"); - this->mParent->logMe (yetToSubscribeDataItemsList); - } - - list unsubscribeList; - list unused; - this->mParent->mClientIndex->remove (this->mClient, removeDataItemList, unused); - - if (!this->mParent->mClientIndex->isSubscribedClient (this->mClient)) { - this->mParent->mDataItemIndex->remove (list (1,this->mClient), unsubscribeList); - } - if (!unsubscribeList.empty ()) { - // Send unsubscribe to framework - this->mParent->mContext.mSubscriptionObj->unsubscribe - ( - unsubscribeList, - this->mParent - ); - LOC_LOGD ("Unsubscribe Request sent to framework for the following data items"); - this->mParent->logMe (unsubscribeList); - } - } while (0); - EXIT_LOG_WITH_ERROR ("%d",result); -} - -void SystemStatusOsObserver :: HandleRequestData :: proc () const { - int result = 0; - ENTRY_LOG (); - - do { - if (mDataItemList.empty ()) { - LOC_LOGV("mDataItemList is empty. Nothing to do. Exiting"); - result = 0; - break; - } - //mDataItemList.sort (); - list yetToSubscribeDataItemsList; - this->mParent->mClientIndex->add (this->mClient, mDataItemList, yetToSubscribeDataItemsList); - this->mParent->mDataItemIndex->add (this->mClient, mDataItemList, yetToSubscribeDataItemsList); - // Send subscription list to framework - if (!mDataItemList.empty ()) { - this->mParent->mContext.mSubscriptionObj->requestData - ( - mDataItemList, - this->mParent - ); - LOC_LOGD ("Subscribe Request sent to framework for the following data items"); - this->mParent->logMe (yetToSubscribeDataItemsList); - } - - } while (0); - EXIT_LOG_WITH_ERROR ("%d",result); -} - -void SystemStatusOsObserver :: HandleUnsubscribeReq :: proc () const { - int result = 0; - ENTRY_LOG (); - do { - if (mDataItemList.empty ()) { - LOC_LOGV("mDataItemList is empty. Nothing to do. Exiting"); - result = 0; - break; - } - //mDataItemList.sort (); - list unsubscribeList; - list unused; - this->mParent->mClientIndex->remove (this->mClient, mDataItemList, unused); - - list :: const_iterator it = mDataItemList.begin (); - for (; it != mDataItemList.end (); ++it) { - list clientListSubs; - list clientListOut; - this->mParent->mDataItemIndex->remove ((*it), - list (1,this->mClient), clientListOut); - // check if there are any other subscribed client for this data item id - this->mParent->mDataItemIndex->getListOfSubscribedClients ( (*it), clientListSubs); - if (clientListSubs.empty()) - { - LOC_LOGD ("Client list subscribed is empty for dataitem - %d",(*it)); - unsubscribeList.push_back((*it)); - } - } - if (!unsubscribeList.empty ()) { - // Send unsubscribe to framework - this->mParent->mContext.mSubscriptionObj->unsubscribe - ( - unsubscribeList, - this->mParent - ); - LOC_LOGD ("Unsubscribe Request sent to framework for the following data items"); - this->mParent->logMe (unsubscribeList); - } - } while (0); - EXIT_LOG_WITH_ERROR ("%d",result); -} - -void SystemStatusOsObserver :: HandleUnsubscribeAllReq :: proc () const { - int result = 0; - ENTRY_LOG (); - do { - list clients (1, this->mClient); - list unsubscribeList; - BREAK_IF_NON_ZERO (2, this->mParent->mClientIndex->remove (this->mClient)); - - - this->mParent->mDataItemIndex->remove (clients, unsubscribeList); - if (!unsubscribeList.empty ()) { - // Send unsubscribe to framework - this->mParent->mContext.mSubscriptionObj->unsubscribe - ( - unsubscribeList, - this->mParent - ); - LOC_LOGD ("Unsubscribe Request sent to framework for the following data items"); - this->mParent->logMe (unsubscribeList); - } - } while (0); - EXIT_LOG_WITH_ERROR ("%d",result); -} - -void SystemStatusOsObserver :: HandleNotify :: getListOfClients - (const list & dlist, list & clients ) const { - - list :: const_iterator it = dlist.begin (); - for (; it != dlist.end (); ++it) { - list clientList; - this->mParent->mDataItemIndex->getListOfSubscribedClients ( (*it), clientList); - list :: iterator citer = clientList.begin (); - for (; citer != clientList.end (); ++citer) { - clients.push_back (*citer); - } - clientList.clear (); - } - // remove duplicates - clients.unique (); -} - -void SystemStatusOsObserver :: HandleNotify :: proc () const { - int result = 0; - ENTRY_LOG (); - do { - // Update Cache with received data items and prepare - // list of data items to be sent. - list :: const_iterator it = mDList.begin (); - list dataItemIdsToBeSent; - for (; it != mDList.end (); ++it) { - bool dataItemUpdated = false; - this->mParent->updateCache (*it, dataItemUpdated); - if (dataItemUpdated) { - dataItemIdsToBeSent.push_back ( (*it)->getId ()); - } - } - - list clientList; - this->getListOfClients (dataItemIdsToBeSent, clientList); - list :: iterator citer = clientList.begin (); - // Send data item to all subscribed clients - LOC_LOGD ("LocTech-Label :: SystemStatusOsObserver :: Data Items Out"); - for (; citer != clientList.end (); ++citer) { - do { - list dataItemIdsSubscribedByThisClient; - list dataItemIdsToBeSentForThisClient; - this->mParent->mClientIndex->getSubscribedList (*citer, dataItemIdsSubscribedByThisClient); - dataItemIdsSubscribedByThisClient.sort (); - dataItemIdsToBeSent.sort (); - set_intersection (dataItemIdsToBeSent.begin (), - dataItemIdsToBeSent.end (), - dataItemIdsSubscribedByThisClient.begin (), - dataItemIdsSubscribedByThisClient.end (), - inserter (dataItemIdsToBeSentForThisClient, - dataItemIdsToBeSentForThisClient.begin ())); - BREAK_IF_NON_ZERO (4,this->mParent->sendCachedDataItems (dataItemIdsToBeSentForThisClient, *citer)); - dataItemIdsSubscribedByThisClient.clear (); - dataItemIdsToBeSentForThisClient.clear (); - } while (0); - } - } while (0); - EXIT_LOG_WITH_ERROR ("%d", result); -} - -void SystemStatusOsObserver :: HandleTurnOn :: proc () const { - int result = 0; - ENTRY_LOG (); - do { - // Send action turn on to framework - this->mParent->mContext.mFrameworkActionReqObj->turnOn(mDataItemId, mTimeOut); - } while (0); - EXIT_LOG_WITH_ERROR ("%d", result); -} - -void SystemStatusOsObserver :: HandleTurnOff :: proc () const { - int result = 0; - ENTRY_LOG (); - do { - // Send action turn off to framework - this->mParent->mContext.mFrameworkActionReqObj->turnOff(mDataItemId); - } while (0); - EXIT_LOG_WITH_ERROR ("%d", result); + } + else { + // not found + reqCache[client] = l; + } } /****************************************************************************** IDataItemSubscription Overrides ******************************************************************************/ -void SystemStatusOsObserver :: subscribe (const list & l, IDataItemObserver * client) { - int result = 0; - ENTRY_LOG (); - do { - if (mContext.mSubscriptionObj != NULL) { - HandleSubscribeReq * msg = new (nothrow) HandleSubscribeReq (this, l, client); - mContext.mMsgTask->sendMsg (msg); +void SystemStatusOsObserver::subscribe( + const list& l, IDataItemObserver* client) +{ + if (nullptr == mContext.mSubscriptionObj) { + LOC_LOGD("%s]: Subscription object is NULL. Caching requests", __func__); + cacheObserverRequest(mSubscribeReqCache, l, client); + return; + } + + struct HandleSubscribeReq : public LocMsg { + HandleSubscribeReq(SystemStatusOsObserver* parent, + const list& l, IDataItemObserver* client) : + mParent(parent), mClient(client), mDataItemList(l) {} + virtual ~HandleSubscribeReq() {} + void proc() const { + + if (mDataItemList.empty()) { + LOC_LOGV("mDataItemList is empty. Nothing to do. Exiting"); + return; + } + + // Handle First Response + list pendingFirstResponseList(0); + mParent->mClientIndex->add(mClient, mDataItemList, pendingFirstResponseList); + + // Do not send first response for only pendingFirstResponseList, + // instead send for all the data items (present in the cache) that + // have been subscribed for each time. + mParent->sendFirstResponse(mDataItemList, mClient); + + list yetToSubscribeDataItemsList(0); + mParent->mDataItemIndex->add(mClient, mDataItemList, yetToSubscribeDataItemsList); + + // Send subscription list to framework + if (!yetToSubscribeDataItemsList.empty()) { + mParent->mContext.mSubscriptionObj->subscribe(yetToSubscribeDataItemsList, mParent); + LOC_LOGD("Subscribe Request sent to framework for the following"); + mParent->logMe(yetToSubscribeDataItemsList); + } } - else { - LOC_LOGE("%s:%d]: Subscription object is NULL", __func__, __LINE__); - result = 1; - } - } while (0); - EXIT_LOG_WITH_ERROR ("%d",result); + SystemStatusOsObserver* mParent; + IDataItemObserver* mClient; + const list mDataItemList; + }; + mContext.mMsgTask->sendMsg(new (nothrow) HandleSubscribeReq(this, l, client)); } -void SystemStatusOsObserver :: updateSubscription (const list & l, IDataItemObserver * client) { - int result = 0; - ENTRY_LOG (); - do { - if (mContext.mSubscriptionObj != NULL) { - mContext.mMsgTask->sendMsg (new (nothrow) HandleUpdateSubscriptionReq (this, l, client)); +void SystemStatusOsObserver::updateSubscription( + const list& l, IDataItemObserver* client) +{ + if (nullptr == mContext.mSubscriptionObj) { + LOC_LOGE("%s:%d]: Subscription object is NULL", __func__, __LINE__); + return; + } + + struct HandleUpdateSubscriptionReq : public LocMsg { + HandleUpdateSubscriptionReq(SystemStatusOsObserver* parent, + const list& l, IDataItemObserver* client) : + mParent(parent), mClient(client), mDataItemList(l) {} + virtual ~HandleUpdateSubscriptionReq() {} + void proc() const { + if (mDataItemList.empty()) { + LOC_LOGV("mDataItemList is empty. Nothing to do. Exiting"); + return; + } + + list currentlySubscribedList(0); + mParent->mClientIndex->getSubscribedList(mClient, currentlySubscribedList); + + list removeDataItemList(0); + set_difference(currentlySubscribedList.begin(), currentlySubscribedList.end(), + mDataItemList.begin(), mDataItemList.end(), + inserter(removeDataItemList,removeDataItemList.begin())); + + // Handle First Response + list pendingFirstResponseList(0); + mParent->mClientIndex->add(mClient, mDataItemList, pendingFirstResponseList); + + // Send First Response + mParent->sendFirstResponse(pendingFirstResponseList, mClient); + + list yetToSubscribeDataItemsList(0); + mParent->mDataItemIndex->add( + mClient, mDataItemList, yetToSubscribeDataItemsList); + + // Send subscription list to framework + if (!yetToSubscribeDataItemsList.empty()) { + mParent->mContext.mSubscriptionObj->subscribe( + yetToSubscribeDataItemsList, mParent); + LOC_LOGD("Subscribe Request sent to framework for the following"); + mParent->logMe(yetToSubscribeDataItemsList); + } + + list unsubscribeList(0); + list unused(0); + mParent->mClientIndex->remove(mClient, removeDataItemList, unused); + + if (!mParent->mClientIndex->isSubscribedClient(mClient)) { + mParent->mDataItemIndex->remove( + list (1,mClient), unsubscribeList); + } + if (!unsubscribeList.empty()) { + // Send unsubscribe to framework + mParent->mContext.mSubscriptionObj->unsubscribe(unsubscribeList, mParent); + LOC_LOGD("Unsubscribe Request sent to framework for the following"); + mParent->logMe(unsubscribeList); + } } - else { - LOC_LOGE("%s:%d]: Subscription object is NULL", __func__, __LINE__); - result = 1; - } - } while (0); - EXIT_LOG_WITH_ERROR ("%d",result); + SystemStatusOsObserver* mParent; + IDataItemObserver* mClient; + const list mDataItemList; + }; + mContext.mMsgTask->sendMsg(new (nothrow) HandleUpdateSubscriptionReq(this, l, client)); } -void SystemStatusOsObserver :: requestData (const list & l, IDataItemObserver * client) { - int result = 0; - ENTRY_LOG (); - do { - if (mContext.mSubscriptionObj != NULL) { - mContext.mMsgTask->sendMsg (new (nothrow) HandleRequestData (this, l, client)); - } - else { - LOC_LOGE("%s:%d]: Subscription object is NULL", __func__, __LINE__); - result = 1; - } - } while (0); +void SystemStatusOsObserver::requestData( + const list& l, IDataItemObserver* client) +{ + if (nullptr == mContext.mSubscriptionObj) { + LOC_LOGD("%s]: Subscription object is NULL. Caching requests", __func__); + cacheObserverRequest(mReqDataCache, l, client); + return; + } - EXIT_LOG_WITH_ERROR ("%d",result); + struct HandleRequestData : public LocMsg { + HandleRequestData(SystemStatusOsObserver* parent, + const list& l, IDataItemObserver* client) : + mParent(parent), mClient(client), mDataItemList(l) {} + virtual ~HandleRequestData() {} + void proc() const { + if (mDataItemList.empty()) { + LOC_LOGV("mDataItemList is empty. Nothing to do. Exiting"); + return; + } + + list yetToSubscribeDataItemsList(0); + mParent->mClientIndex->add( + mClient, mDataItemList, yetToSubscribeDataItemsList); + mParent->mDataItemIndex->add( + mClient, mDataItemList, yetToSubscribeDataItemsList); + + // Send subscription list to framework + if (!mDataItemList.empty()) { + mParent->mContext.mSubscriptionObj->requestData(mDataItemList, mParent); + LOC_LOGD("Subscribe Request sent to framework for the following"); + mParent->logMe(yetToSubscribeDataItemsList); + } + } + SystemStatusOsObserver* mParent; + IDataItemObserver* mClient; + const list mDataItemList; + }; + mContext.mMsgTask->sendMsg(new (nothrow) HandleRequestData(this, l, client)); } -void SystemStatusOsObserver :: unsubscribe (const list & l, IDataItemObserver * client) { - int result = 0; - ENTRY_LOG (); - do { - if (mContext.mSubscriptionObj != NULL) { - mContext.mMsgTask->sendMsg (new (nothrow) HandleUnsubscribeReq (this, l, client)); +void SystemStatusOsObserver::unsubscribe( + const list& l, IDataItemObserver* client) +{ + if (nullptr == mContext.mSubscriptionObj) { + LOC_LOGE("%s:%d]: Subscription object is NULL", __func__, __LINE__); + return; + } + struct HandleUnsubscribeReq : public LocMsg { + HandleUnsubscribeReq(SystemStatusOsObserver* parent, + const list& l, IDataItemObserver* client) : + mParent(parent), mClient(client), mDataItemList(l) {} + virtual ~HandleUnsubscribeReq() {} + void proc() const { + if (mDataItemList.empty()) { + LOC_LOGV("mDataItemList is empty. Nothing to do. Exiting"); + return; + } + + list unsubscribeList(0); + list unused(0); + mParent->mClientIndex->remove(mClient, mDataItemList, unused); + + for (auto each : mDataItemList) { + list clientListSubs(0); + list clientListOut(0); + mParent->mDataItemIndex->remove( + each, list (1,mClient), clientListOut); + // check if there are any other subscribed client for this data item id + mParent->mDataItemIndex->getListOfSubscribedClients(each, clientListSubs); + if (clientListSubs.empty()) + { + LOC_LOGD("Client list subscribed is empty for dataitem - %d", each); + unsubscribeList.push_back(each); + } + } + + if (!unsubscribeList.empty()) { + // Send unsubscribe to framework + mParent->mContext.mSubscriptionObj->unsubscribe(unsubscribeList, mParent); + LOC_LOGD("Unsubscribe Request sent to framework for the following data items"); + mParent->logMe(unsubscribeList); + } } - else { - LOC_LOGE("%s:%d]: Subscription object is NULL", __func__, __LINE__); - result = 1; - } - } while (0); - EXIT_LOG_WITH_ERROR ("%d",result); + SystemStatusOsObserver* mParent; + IDataItemObserver* mClient; + const list mDataItemList; + }; + mContext.mMsgTask->sendMsg(new (nothrow) HandleUnsubscribeReq(this, l, client)); } -void SystemStatusOsObserver :: unsubscribeAll (IDataItemObserver * client) { - int result = 0; - ENTRY_LOG (); - do { - if (mContext.mSubscriptionObj != NULL) { - mContext.mMsgTask->sendMsg (new (nothrow) HandleUnsubscribeAllReq (this, client)); +void SystemStatusOsObserver::unsubscribeAll(IDataItemObserver* client) +{ + if (nullptr == mContext.mSubscriptionObj) { + LOC_LOGE("%s:%d]: Subscription object is NULL", __func__, __LINE__); + return; + } + + struct HandleUnsubscribeAllReq : public LocMsg { + HandleUnsubscribeAllReq(SystemStatusOsObserver* parent, + IDataItemObserver* client) : + mParent(parent), mClient(client) {} + virtual ~HandleUnsubscribeAllReq() {} + void proc() const { + list clients(1, mClient); + list unsubscribeList(0); + if(0 == mParent->mClientIndex->remove(mClient)) { + return; + } + mParent->mDataItemIndex->remove(clients, unsubscribeList); + + if (!unsubscribeList.empty()) { + // Send unsubscribe to framework + mParent->mContext.mSubscriptionObj->unsubscribe(unsubscribeList, mParent); + LOC_LOGD("Unsubscribe Request sent to framework for the following data items"); + mParent->logMe(unsubscribeList); + } } - else { - LOC_LOGE("%s:%d]: Subscription object is NULL", __func__, __LINE__); - result = 1; - } - } while (0); - EXIT_LOG_WITH_ERROR ("%d",result); + SystemStatusOsObserver* mParent; + IDataItemObserver* mClient; + }; + mContext.mMsgTask->sendMsg(new (nothrow) HandleUnsubscribeAllReq(this, client)); } /****************************************************************************** IDataItemObserver Overrides ******************************************************************************/ -void SystemStatusOsObserver::getName(string & name) { - name = mAddress; -} +void SystemStatusOsObserver::notify(const list& dlist) +{ + list dataItemList(0); -void SystemStatusOsObserver::notify(const std::list & dlist) { - int result = 0; - ENTRY_LOG (); - do { - list :: const_iterator it = dlist.begin (); - list dataItemList; - list ids; - LOC_LOGD("LocTech-Label :: SystemStatusOsObserver :: Data Items In"); - for (; it != dlist.end (); ++it) { - if (*it != NULL) { - string dv; - (*it)->stringify(dv); - LOC_LOGD("LocTech-Value :: Data Item Value: %s", dv.c_str ()); - IDataItemCore * dataitem = DataItemsFactoryProxy::createNewDataItem((*it)->getId()); - BREAK_IF_ZERO (2, dataitem); - // Copy contents into the newly created data item - dataitem->copy(*it); - dataItemList.push_back(dataitem); - ids.push_back((*it)->getId()); + for (auto each : dlist) { + string dv; + each->stringify(dv); + LOC_LOGD("notify: DataItem In Value:%s", dv.c_str()); + + IDataItemCore* di = DataItemsFactoryProxy::createNewDataItem(each->getId()); + if (nullptr == di) { + LOC_LOGE("Unable to create dataitem:%d", each->getId()); + return; + } + + // 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); + } + } + + struct HandleNotify : public LocMsg { + HandleNotify(SystemStatusOsObserver* parent, const list& l) : + mParent(parent), mDList(l) {} + virtual ~HandleNotify() { + for (auto each : mDList) { + delete each; } } - mContext.mMsgTask->sendMsg(new (nothrow) HandleNotify (this, dataItemList)); - } while (0); - EXIT_LOG_WITH_ERROR ("%d", result); + void proc() const { + // Update Cache with received data items and prepare + // list of data items to be sent. + list dataItemIdsToBeSent(0); + for (auto item : mDList) { + bool dataItemUpdated = false; + mParent->updateCache(item, dataItemUpdated); + if (dataItemUpdated) { + dataItemIdsToBeSent.push_back(item->getId()); + } + } + + // Send data item to all subscribed clients + list clientList(0); + for (auto each : dataItemIdsToBeSent) { + list clients(0); + mParent->mDataItemIndex->getListOfSubscribedClients(each, clients); + for (auto each_cient: clients) { + clientList.push_back(each_cient); + } + } + clientList.unique(); + + for (auto client : clientList) { + list dataItemIdsSubscribedByThisClient(0); + list dataItemIdsToBeSentForThisClient(0); + mParent->mClientIndex->getSubscribedList( + client, dataItemIdsSubscribedByThisClient); + dataItemIdsSubscribedByThisClient.sort(); + dataItemIdsToBeSent.sort(); + + set_intersection(dataItemIdsToBeSent.begin(), + dataItemIdsToBeSent.end(), + dataItemIdsSubscribedByThisClient.begin(), + dataItemIdsSubscribedByThisClient.end(), + inserter(dataItemIdsToBeSentForThisClient, + dataItemIdsToBeSentForThisClient.begin())); + + mParent->sendCachedDataItems(dataItemIdsToBeSentForThisClient, client); + dataItemIdsSubscribedByThisClient.clear(); + dataItemIdsToBeSentForThisClient.clear(); + } + } + SystemStatusOsObserver* mParent; + const list mDList; + }; + mContext.mMsgTask->sendMsg(new (nothrow) HandleNotify(this, dataItemList)); } /****************************************************************************** IFrameworkActionReq Overrides ******************************************************************************/ -void SystemStatusOsObserver :: turnOn (DataItemId dit, int timeOut) { - int result = 0; - ENTRY_LOG (); - do { - if (mContext.mFrameworkActionReqObj != NULL) { - // Check if data item exists in mActiveRequestCount - map :: iterator citer = mActiveRequestCount.find (dit); - if (citer == mActiveRequestCount.end ()) { - // Data item not found in map - // Add reference count as 1 and add dataitem to map - pair cpair (dit, 1); - mActiveRequestCount.insert (cpair); - LOC_LOGD("Sending turnOn request"); - // Send action turn on to framework - mContext.mMsgTask->sendMsg (new (nothrow) HandleTurnOn (this, dit, timeOut)); - } else { - // Found in map, update reference count - citer->second++; - LOC_LOGD("HandleTurnOn - Data item:%d Num_refs:%d",dit,citer->second); - } - } - else { - LOC_LOGE("%s:%d]: Framework action request object is NULL", __func__, __LINE__); - result = 1; - } - } while (0); +void SystemStatusOsObserver::turnOn(DataItemId dit, int timeOut) +{ + if (nullptr == mContext.mFrameworkActionReqObj) { + LOC_LOGE("%s:%d]: Framework action request object is NULL", __func__, __LINE__); + return; + } - EXIT_LOG_WITH_ERROR ("%d", result); + // Check if data item exists in mActiveRequestCount + map::iterator citer = mActiveRequestCount.find(dit); + if (citer == mActiveRequestCount.end()) { + // Data item not found in map + // Add reference count as 1 and add dataitem to map + pair cpair(dit, 1); + mActiveRequestCount.insert(cpair); + LOC_LOGD("Sending turnOn request"); + + // Send action turn on to framework + struct HandleTurnOnMsg : public LocMsg { + HandleTurnOnMsg(IFrameworkActionReq* framework, + DataItemId dit, int timeOut) : + mFrameworkActionReqObj(framework), mDataItemId(dit), mTimeOut(timeOut) {} + virtual ~HandleTurnOnMsg() {} + void proc() const { + mFrameworkActionReqObj->turnOn(mDataItemId, mTimeOut); + } + IFrameworkActionReq* mFrameworkActionReqObj; + DataItemId mDataItemId; + int mTimeOut; + }; + mContext.mMsgTask->sendMsg(new (nothrow) HandleTurnOnMsg(this, dit, timeOut)); + } + else { + // Found in map, update reference count + citer->second++; + LOC_LOGD("turnOn - Data item:%d Num_refs:%d", dit, citer->second); + } } -void SystemStatusOsObserver :: turnOff (DataItemId dit) { - int result = 0; - ENTRY_LOG (); - do { - if (mContext.mFrameworkActionReqObj != NULL) { - // Check if data item exists in mActiveRequestCount - map :: iterator citer = mActiveRequestCount.find (dit); - if (citer != mActiveRequestCount.end ()) { - citer->second--; - LOC_LOGD("HandleTurnOff - Data item:%d Remaining Num_refs:%d",dit,citer->second); +void SystemStatusOsObserver::turnOff(DataItemId dit) +{ + if (nullptr == mContext.mFrameworkActionReqObj) { + LOC_LOGE("%s:%d]: Framework action request object is NULL", __func__, __LINE__); + return; + } - if(citer->second == 0) { - LOC_LOGD("Sending turnOff request"); - // if this was last reference, remove item from map and turn off module - mActiveRequestCount.erase(citer); - // Send action turn off to framework - mContext.mMsgTask->sendMsg (new (nothrow) HandleTurnOff (this, dit)); + // Check if data item exists in mActiveRequestCount + map::iterator citer = mActiveRequestCount.find(dit); + if (citer != mActiveRequestCount.end()) { + // found + citer->second--; + LOC_LOGD("turnOff - Data item:%d Remaining:%d", dit, citer->second); + if(citer->second == 0) { + // if this was last reference, remove item from map and turn off module + mActiveRequestCount.erase(citer); + + // Send action turn off to framework + struct HandleTurnOffMsg : public LocMsg { + HandleTurnOffMsg(IFrameworkActionReq* framework, DataItemId dit) : + mFrameworkActionReqObj(framework), mDataItemId(dit) {} + virtual ~HandleTurnOffMsg() {} + void proc() const { + mFrameworkActionReqObj->turnOff(mDataItemId); } - } else { - // Not found in map - LOC_LOGD ("Data item id %d not found in FrameworkModuleMap",dit); - } + IFrameworkActionReq* mFrameworkActionReqObj; + DataItemId mDataItemId; + }; + mContext.mMsgTask->sendMsg( + new (nothrow) HandleTurnOffMsg(mContext.mFrameworkActionReqObj, dit)); } - else { - LOC_LOGE("%s:%d]: Framework action request object is NULL", __func__, __LINE__); - result = 1; - } - } while (0); - EXIT_LOG_WITH_ERROR ("%d", result); + } } /****************************************************************************** Helpers ******************************************************************************/ -void SystemStatusOsObserver :: logMe (const list & l) { - list :: const_iterator it = l.begin (); - for (;it != l.end (); ++it) { - LOC_LOGD ("DataItem %d",*it); +void SystemStatusOsObserver::sendFirstResponse( + const list& l, IDataItemObserver* to) +{ + if (l.empty()) { + LOC_LOGV("list is empty. Nothing to do. Exiting"); + return; } -} -int SystemStatusOsObserver :: sendFirstResponse (const list & l, IDataItemObserver * to) { - int result = 0; - ENTRY_LOG (); - do { - if (l.empty ()) { - LOC_LOGV("list is empty. Nothing to do. Exiting"); - result = 0; - break; - } + string clientName; + to->getName(clientName); + list dataItems(0); - string clientName; - to->getName (clientName); - LOC_LOGD ("First response sent for the following data items To Client: %s", clientName.c_str()); - - list dataItems; - list :: const_iterator diditer = l.begin (); - for (; diditer != l.end (); ++diditer) { - map :: const_iterator citer = mDataItemCache.find (*diditer); - if (citer != mDataItemCache.end ()) { - string dv; - IDataItemCore * di = citer->second; - di->stringify (dv); - LOC_LOGD ("LocTech-Value :: Data Item: %s", dv.c_str ()); - dataItems.push_back (citer->second); - } - } - if (dataItems.empty ()) { - LOC_LOGV("No items to notify. Nothing to do. Exiting"); - result = 0; - break; - } - - // Notify Client - to->notify (dataItems); - - } while (0); - EXIT_LOG_WITH_ERROR ("%d", result); - return result; -} - -int SystemStatusOsObserver :: sendCachedDataItems (const list & l, IDataItemObserver * to) { - int result = 0; - ENTRY_LOG (); - do { - list dataItems; - list :: const_iterator it = l.begin (); - string clientName; - to->getName (clientName); - LOC_LOGD ("LocTech-Value :: To Client: %s", clientName.c_str ()); - for (; it != l.end (); ++it) { + for (auto each : l) { + map::const_iterator citer = mDataItemCache.find(each); + if (citer != mDataItemCache.end()) { string dv; - IDataItemCore * di = this->mDataItemCache [ (*it) ]; - di->stringify (dv); - LOC_LOGI("LocTech-Value :: Data Item: %s >> %s", dv.c_str(), clientName.c_str()); - dataItems.push_back (di); + citer->second->stringify(dv); + LOC_LOGI("DataItem: %s >> %s", dv.c_str(), clientName.c_str()); + dataItems.push_back(citer->second); } - - to->notify (dataItems); - - } while (0); - EXIT_LOG_WITH_ERROR ("%d", result); - return result; + } + if (dataItems.empty()) { + LOC_LOGV("No items to notify. Nothing to do. Exiting"); + return; + } + to->notify(dataItems); } -int SystemStatusOsObserver :: updateCache (IDataItemCore * d, bool &dataItemUpdated) { - int result = 0; - ENTRY_LOG (); - do { - BREAK_IF_ZERO (1, d); - // Check if data item exists in cache - map :: iterator citer = mDataItemCache.find (d->getId ()); - if (citer == mDataItemCache.end ()) { - // New data item; not found in cache - IDataItemCore * dataitem = DataItemsFactoryProxy::createNewDataItem(d->getId()); - BREAK_IF_ZERO (2, dataitem); - // Copy the contents of the data item - dataitem->copy (d); - pair cpair (d->getId (), dataitem); - // Insert in mDataItemCache - mDataItemCache.insert (cpair); - dataItemUpdated = true; - } else { - // Found in cache; Update cache if necessary - BREAK_IF_NON_ZERO(3, citer->second->copy (d, &dataItemUpdated)); +void SystemStatusOsObserver::sendCachedDataItems( + const list& l, IDataItemObserver* to) +{ + string clientName; + to->getName(clientName); + list dataItems(0); + + for (auto each : l) { + string dv; + IDataItemCore* di = mDataItemCache[each]; + di->stringify(dv); + LOC_LOGI("DataItem: %s >> %s", dv.c_str(), clientName.c_str()); + dataItems.push_back(di); + } + to->notify(dataItems); +} + +void SystemStatusOsObserver::updateCache(IDataItemCore* d, bool& dataItemUpdated) +{ + if (nullptr == d) { + return; + } + + // Check if data item exists in cache + map::iterator citer = + mDataItemCache.find(d->getId()); + if (citer == mDataItemCache.end()) { + // New data item; not found in cache + IDataItemCore* dataitem = DataItemsFactoryProxy::createNewDataItem(d->getId()); + if (nullptr == dataitem) { + return; } - if (dataItemUpdated) { - LOC_LOGV("DataItem:%d updated:%d", d->getId (), dataItemUpdated); + // Copy the contents of the data item + dataitem->copy(d); + pair cpair(d->getId(), dataitem); + // Insert in mDataItemCache + mDataItemCache.insert(cpair); + dataItemUpdated = true; + } + else { + // Found in cache; Update cache if necessary + if(0 == citer->second->copy(d, &dataItemUpdated)) { + return; } - } while (0); + } - EXIT_LOG_WITH_ERROR ("%d", result); - return result; + if (dataItemUpdated) { + LOC_LOGV("DataItem:%d updated:%d", d->getId(), dataItemUpdated); + } } } // namespace loc_core diff --git a/core/SystemStatusOsObserver.h b/core/SystemStatusOsObserver.h index 8e42d211..985e5c99 100644 --- a/core/SystemStatusOsObserver.h +++ b/core/SystemStatusOsObserver.h @@ -29,36 +29,34 @@ #ifndef __SYSTEM_STATUS_OSOBSERVER__ #define __SYSTEM_STATUS_OSOBSERVER__ -#include +#include #include #include #include #include #include -#include -#include + #include +#include #include +#include namespace loc_core { - /****************************************************************************** SystemStatusOsObserver ******************************************************************************/ +using namespace std; + // Forward Declarations class IDataItemCore; - -template -class IClientIndex; - -template -class IDataItemIndex; +template class IClientIndex; +template class IDataItemIndex; struct SystemContext { - IDataItemSubscription *mSubscriptionObj; - IFrameworkActionReq *mFrameworkActionReqObj; - const MsgTask *mMsgTask; + IDataItemSubscription* mSubscriptionObj; + IFrameworkActionReq* mFrameworkActionReqObj; + const MsgTask* mMsgTask; inline SystemContext() : mSubscriptionObj(NULL), @@ -66,6 +64,8 @@ struct SystemContext { mMsgTask(NULL) {} }; +typedef map> ObserverReqCache; + // Clients wanting to get data from OS/Framework would need to // subscribe with OSObserver using IDataItemSubscription interface. // Such clients would need to implement IDataItemObserver interface @@ -80,252 +80,54 @@ public: ~SystemStatusOsObserver(); // To set the subscription object - inline void setSubscriptionObj(IDataItemSubscription *subscriptionObj) { - mContext.mSubscriptionObj = subscriptionObj; - }; + virtual void setSubscriptionObj(IDataItemSubscription* subscriptionObj); // To set the framework action request object - inline void setFrameworkActionReqObj(IFrameworkActionReq *frameworkActionReqObj) { + inline void setFrameworkActionReqObj(IFrameworkActionReq* frameworkActionReqObj) { mContext.mFrameworkActionReqObj = frameworkActionReqObj; } - // IDataItemObserver Overrides - virtual void getName (string & name); - virtual void notify (const std::list & dlist); - // IDataItemSubscription Overrides - virtual void subscribe (const std :: list & l, IDataItemObserver * client); - virtual void updateSubscription - ( - const std :: list & l, - IDataItemObserver * client - ); - virtual void requestData - ( - const std :: list & l, - IDataItemObserver * client - ); - virtual void unsubscribe (const std :: list & l, IDataItemObserver * client); - virtual void unsubscribeAll (IDataItemObserver * client); + virtual void subscribe(const list& l, IDataItemObserver* client); + virtual void updateSubscription(const list& l, IDataItemObserver* client); + virtual void requestData(const list& l, IDataItemObserver* client); + virtual void unsubscribe(const list& l, IDataItemObserver* client); + virtual void unsubscribeAll(IDataItemObserver* client); + + // IDataItemObserver Overrides + virtual void notify(const list& dlist); + inline virtual void getName(string& name) { + name = mAddress; + } // IFrameworkActionReq Overrides - virtual void turnOn (DataItemId dit, int timeOut = 0); - virtual void turnOff (DataItemId dit); + virtual void turnOn(DataItemId dit, int timeOut = 0); + virtual void turnOff(DataItemId dit); private: + SystemContext mContext; + const string mAddress; + IClientIndex* mClientIndex; + IDataItemIndex* mDataItemIndex; + map mDataItemCache; + map mActiveRequestCount; - SystemContext mContext; - const string mAddress; - IClientIndex *mClientIndex; - IDataItemIndex *mDataItemIndex; - map < DataItemId, IDataItemCore * > mDataItemCache; - map < DataItemId, int > mActiveRequestCount; - - // Nested types - // Messages - struct HandleMsgBase : public LocMsg { - HandleMsgBase (SystemStatusOsObserver * parent); - virtual ~HandleMsgBase (); - // Data members - SystemStatusOsObserver * mParent; - }; + // Cache the subscribe and requestData till subscription obj is obtained + ObserverReqCache mSubscribeReqCache; + ObserverReqCache mReqDataCache; + void cacheObserverRequest(ObserverReqCache& reqCache, + const list& l, IDataItemObserver* client); // Helpers - int sendFirstResponse - ( - const list & l, - IDataItemObserver * to - ); - - int sendCachedDataItems - ( - const list & l, - IDataItemObserver * to - ); - - int updateCache (IDataItemCore * d, bool &dataItemUpdated); - void logMe (const list & l); - - // Messages - struct HandleClientMsg : public LocMsg { - HandleClientMsg (SystemStatusOsObserver * parent, IDataItemObserver * client); - virtual ~HandleClientMsg (); - // Data Members - SystemStatusOsObserver * mParent; - IDataItemObserver * mClient; - }; - - struct HandleSubscribeReq : public HandleClientMsg { - HandleSubscribeReq (SystemStatusOsObserver * parent, - const list & l, - IDataItemObserver * client); - virtual ~HandleSubscribeReq (); - void proc () const; - // Data members - const list mDataItemList; - }; - - struct HandleUpdateSubscriptionReq : public HandleClientMsg { - HandleUpdateSubscriptionReq (SystemStatusOsObserver * parent, - const list & l, - IDataItemObserver * client); - virtual ~HandleUpdateSubscriptionReq (); - void proc () const; - // Data members - const list mDataItemList; - }; - - struct HandleRequestData : public HandleClientMsg { - HandleRequestData (SystemStatusOsObserver * parent, - const list & l, - IDataItemObserver * client); - virtual ~HandleRequestData (); - void proc () const; - const list mDataItemList; - }; - - struct HandleUnsubscribeReq : public HandleClientMsg { - HandleUnsubscribeReq (SystemStatusOsObserver * parent, - const list & l, - IDataItemObserver * client); - virtual ~HandleUnsubscribeReq (); - void proc () const; - // Data members - const list mDataItemList; - }; - - struct HandleUnsubscribeAllReq : public HandleClientMsg { - HandleUnsubscribeAllReq - ( - SystemStatusOsObserver * parent, - IDataItemObserver * client - ); - virtual ~HandleUnsubscribeAllReq (); - void proc () const; - }; - - struct HandleNotify : public HandleMsgBase { - HandleNotify (SystemStatusOsObserver * parent, list dlist); - virtual ~HandleNotify (); - void getListOfClients - ( - const list & dlist, - list & clients - ) const; - void proc () const; - // Data members - list mDList; - }; - - struct HandleTurnOn : public HandleMsgBase { - HandleTurnOn (SystemStatusOsObserver * parent, - const DataItemId dit, - const int timeOut); - virtual ~HandleTurnOn (); - void proc () const; - // Data members - DataItemId mDataItemId; - int mTimeOut; - }; - - struct HandleTurnOff : public HandleMsgBase { - HandleTurnOff (SystemStatusOsObserver * parent,const DataItemId dit); - virtual ~HandleTurnOff (); - void proc () const; - // Data members - DataItemId mDataItemId; - }; - -}; - - -/****************************************************************************** - Messages -******************************************************************************/ -// Ctors -inline SystemStatusOsObserver :: HandleMsgBase :: HandleMsgBase (SystemStatusOsObserver * parent) -: -mParent (parent) -{} - -inline SystemStatusOsObserver :: HandleClientMsg :: HandleClientMsg -( - SystemStatusOsObserver * parent, - IDataItemObserver * client -) -: -mParent (parent), -mClient (client) -{} - -inline SystemStatusOsObserver :: HandleSubscribeReq :: HandleSubscribeReq - (SystemStatusOsObserver * parent, const list & l, IDataItemObserver * client) -: -HandleClientMsg (parent, client), mDataItemList (l) -{} - -inline SystemStatusOsObserver :: HandleUpdateSubscriptionReq :: HandleUpdateSubscriptionReq - (SystemStatusOsObserver * parent, const list & l, IDataItemObserver * client) -: -HandleClientMsg (parent, client), mDataItemList (l) -{} - -inline SystemStatusOsObserver :: HandleRequestData :: HandleRequestData - (SystemStatusOsObserver * parent, const list & l, IDataItemObserver * client) -: -HandleClientMsg (parent, client), mDataItemList (l) -{} - -inline SystemStatusOsObserver :: HandleUnsubscribeReq :: HandleUnsubscribeReq - (SystemStatusOsObserver * parent, const list & l, IDataItemObserver * client) -: -HandleClientMsg (parent, client), mDataItemList (l) -{} - -inline SystemStatusOsObserver :: HandleUnsubscribeAllReq :: HandleUnsubscribeAllReq - (SystemStatusOsObserver * parent, IDataItemObserver * client) -: -HandleClientMsg (parent, client) -{} - -inline SystemStatusOsObserver :: HandleNotify :: HandleNotify - (SystemStatusOsObserver * parent, list dlist) -: -HandleMsgBase (parent), mDList (dlist) -{} - -inline SystemStatusOsObserver :: HandleTurnOn :: HandleTurnOn - (SystemStatusOsObserver * parent, const DataItemId dit,const int timeOut) -: -HandleMsgBase (parent), mDataItemId (dit), mTimeOut (timeOut) -{} - -inline SystemStatusOsObserver :: HandleTurnOff :: HandleTurnOff - (SystemStatusOsObserver * parent, const DataItemId dit) -: -HandleMsgBase (parent), mDataItemId (dit) -{} - -// Dtors -inline SystemStatusOsObserver :: HandleMsgBase :: ~HandleMsgBase () {} -inline SystemStatusOsObserver :: HandleClientMsg :: ~HandleClientMsg () {} -inline SystemStatusOsObserver :: HandleSubscribeReq :: ~HandleSubscribeReq () {} -inline SystemStatusOsObserver :: HandleUpdateSubscriptionReq :: ~HandleUpdateSubscriptionReq() {} -inline SystemStatusOsObserver :: HandleRequestData :: ~HandleRequestData() {} -inline SystemStatusOsObserver :: HandleUnsubscribeReq :: ~HandleUnsubscribeReq () {} -inline SystemStatusOsObserver :: HandleUnsubscribeAllReq :: ~HandleUnsubscribeAllReq () {} - -inline SystemStatusOsObserver :: HandleNotify :: ~HandleNotify () { - list :: iterator it = mDList.begin (); - for (; it != mDList.end (); ++it) { - delete *it; - *it = NULL; + void sendFirstResponse(const list& l, IDataItemObserver* to); + void sendCachedDataItems(const list& l, IDataItemObserver* to); + void updateCache(IDataItemCore* d, bool& dataItemUpdated); + inline void logMe(const list& l) { + for (auto id : l) { + LOC_LOGD("DataItem %d", id); + } } -} - -inline SystemStatusOsObserver :: HandleTurnOn :: ~HandleTurnOn () {} -inline SystemStatusOsObserver :: HandleTurnOff :: ~HandleTurnOff () {} - +}; } // namespace loc_core diff --git a/gnss/GnssAdapter.cpp b/gnss/GnssAdapter.cpp index d4ffcb25..809e27d9 100644 --- a/gnss/GnssAdapter.cpp +++ b/gnss/GnssAdapter.cpp @@ -67,7 +67,8 @@ GnssAdapter::GnssAdapter() : mAgpsManager(), mAgpsCbInfo(), mSystemStatus(SystemStatus::getInstance(mMsgTask)), - mServerUrl("") + mServerUrl(""), + mXtraObserver(mSystemStatus->getOsObserver(), mMsgTask) { LOC_LOGD("%s]: Constructor %p", __func__, this); mUlpPositionMode.mode = LOC_POSITION_MODE_INVALID; diff --git a/gnss/GnssAdapter.h b/gnss/GnssAdapter.h index 3cb2c64b..fb50f285 100644 --- a/gnss/GnssAdapter.h +++ b/gnss/GnssAdapter.h @@ -106,11 +106,11 @@ class GnssAdapter : public LocAdapterBase { // This must be initialized via initAgps() AgpsManager mAgpsManager; AgpsCbInfo mAgpsCbInfo; - XtraSystemStatusObserver mXtraObserver; /* === SystemStatus ===================================================================== */ SystemStatus* mSystemStatus; std::string mServerUrl; + XtraSystemStatusObserver mXtraObserver; /*==== CONVERSION ===================================================================*/ static void convertOptions(LocPosMode& out, const LocationOptions& options); @@ -280,10 +280,6 @@ public: void injectLocationCommand(double latitude, double longitude, float accuracy); void injectTimeCommand(int64_t time, int64_t timeReference, int32_t uncertainty); - inline void updateConnectionStatusCommand(bool connected, uint8_t type) { - mXtraObserver.updateConnectionStatus(connected, type); - } - }; #endif //GNSS_ADAPTER_H diff --git a/gnss/XtraSystemStatusObserver.cpp b/gnss/XtraSystemStatusObserver.cpp index 58a8522d..ce08f648 100644 --- a/gnss/XtraSystemStatusObserver.cpp +++ b/gnss/XtraSystemStatusObserver.cpp @@ -45,40 +45,55 @@ #include #include #include +#include +#include -using namespace std; using namespace loc_core; #define XTRA_HAL_SOCKET_NAME "/data/vendor/location/xtra/socket_hal_xtra" bool XtraSystemStatusObserver::updateLockStatus(uint32_t lock) { - std::stringstream ss; + stringstream ss; ss << "gpslock"; ss << " " << lock; ss << "\n"; // append seperator return ( sendEvent(ss) ); } -bool XtraSystemStatusObserver::updateConnectionStatus(bool connected, uint8_t type) { - std::stringstream ss; +bool XtraSystemStatusObserver::updateConnectionStatus(bool connected, uint32_t type) { + stringstream ss; ss << "connection"; ss << " " << (connected ? "1" : "0"); ss << " " << (int)type; ss << "\n"; // append seperator return ( sendEvent(ss) ); } +bool XtraSystemStatusObserver::updateTac(const string& tac) { + stringstream ss; + ss << "tac"; + ss << " " << tac.c_str(); + ss << "\n"; // append seperator + return ( sendEvent(ss) ); +} -bool XtraSystemStatusObserver::sendEvent(std::stringstream& event) { +bool XtraSystemStatusObserver::updateMccMnc(const string& mccmnc) { + stringstream ss; + ss << "mncmcc"; + ss << " " << mccmnc.c_str(); + ss << "\n"; // append seperator + return ( sendEvent(ss) ); +} + +bool XtraSystemStatusObserver::sendEvent(const stringstream& event) { int socketFd = createSocket(); if (socketFd < 0) { LOC_LOGe("XTRA unreachable. sending failed."); return false; } - const std::string& data = event.str(); + const string& data = event.str(); int remain = data.length(); ssize_t sent = 0; - while (remain > 0 && (sent = ::send(socketFd, data.c_str() + (data.length() - remain), remain, MSG_NOSIGNAL)) > 0) { @@ -125,3 +140,95 @@ void XtraSystemStatusObserver::closeSocket(const int socketFd) { } } } + +void XtraSystemStatusObserver::subscribe(bool yes) +{ + // Subscription data list + list subItemIdList; + subItemIdList.push_back(NETWORKINFO_DATA_ITEM_ID); + subItemIdList.push_back(MCCMNC_DATA_ITEM_ID); + + if (yes) { + mSystemStatusObsrvr->subscribe(subItemIdList, this); + + list reqItemIdList; + reqItemIdList.push_back(TAC_DATA_ITEM_ID); + + mSystemStatusObsrvr->requestData(reqItemIdList, this); + + } else { + mSystemStatusObsrvr->unsubscribe(subItemIdList, this); + } +} + +// IDataItemObserver overrides +void XtraSystemStatusObserver::getName(string& name) +{ + name = "XtraSystemStatusObserver"; +} + +void XtraSystemStatusObserver::notify(const list& dlist) +{ + struct handleOsObserverUpdateMsg : public LocMsg { + XtraSystemStatusObserver* mXtraSysStatObj; + list mDataItemList; + + inline handleOsObserverUpdateMsg(XtraSystemStatusObserver* xtraSysStatObs, + const list& dataItemList) : + mXtraSysStatObj(xtraSysStatObs) { + for (auto eachItem : dataItemList) { + IDataItemCore* dataitem = DataItemsFactoryProxy::createNewDataItem( + eachItem->getId()); + if (NULL == dataitem) { + break; + } + // Copy the contents of the data item + dataitem->copy(eachItem); + + mDataItemList.push_back(dataitem); + } + } + + inline ~handleOsObserverUpdateMsg() { + for (auto each : mDataItemList) { + delete each; + } + } + + inline void proc() const { + for (auto each : mDataItemList) { + switch (each->getId()) + { + case NETWORKINFO_DATA_ITEM_ID: + { + SystemStatusNetworkInfo* networkInfo = + reinterpret_cast(each); + mXtraSysStatObj->updateConnectionStatus(networkInfo->mConnected, + networkInfo->mType); + } + break; + + case TAC_DATA_ITEM_ID: + { + SystemStatusTac* tac = reinterpret_cast(each); + mXtraSysStatObj->updateTac(tac->mValue); + } + break; + + case MCCMNC_DATA_ITEM_ID: + { + SystemStatusMccMnc* mccmnc = reinterpret_cast(each); + mXtraSysStatObj->updateMccMnc(mccmnc->mValue); + } + break; + + default: + break; + } + } + } + }; + mMsgTask->sendMsg(new (nothrow) handleOsObserverUpdateMsg(this, dlist)); +} + + diff --git a/gnss/XtraSystemStatusObserver.h b/gnss/XtraSystemStatusObserver.h index e49f17b7..42f49b53 100644 --- a/gnss/XtraSystemStatusObserver.h +++ b/gnss/XtraSystemStatusObserver.h @@ -29,25 +29,42 @@ #ifndef XTRA_SYSTEM_STATUS_OBS_H #define XTRA_SYSTEM_STATUS_OBS_H -#include +#include +#include + +using namespace std; +using loc_core::IOsObserver; +using loc_core::IDataItemObserver; +using loc_core::IDataItemCore; -class XtraSystemStatusObserver { +class XtraSystemStatusObserver : public IDataItemObserver { public : // constructor & destructor - XtraSystemStatusObserver() { + inline XtraSystemStatusObserver(IOsObserver* sysStatObs, const MsgTask* msgTask): + mSystemStatusObsrvr(sysStatObs), mMsgTask(msgTask) { + subscribe(true); } + inline XtraSystemStatusObserver() {}; + inline virtual ~XtraSystemStatusObserver() { subscribe(false); } - virtual ~XtraSystemStatusObserver() { - } + // IDataItemObserver overrides + inline virtual void getName(string& name); + virtual void notify(const list& dlist); bool updateLockStatus(uint32_t lock); - bool updateConnectionStatus(bool connected, uint8_t type); + bool updateConnectionStatus(bool connected, uint32_t type); + bool updateTac(const string& tac); + bool updateMccMnc(const string& mccmnc); + inline const MsgTask* getMsgTask() { return mMsgTask; } + void subscribe(bool yes); private: int createSocket(); void closeSocket(const int32_t socketFd); - bool sendEvent(std::stringstream& event); + bool sendEvent(const stringstream& event); + IOsObserver* mSystemStatusObsrvr; + const MsgTask* mMsgTask; }; diff --git a/gnss/location_gnss.cpp b/gnss/location_gnss.cpp index a99d8efb..19399dea 100644 --- a/gnss/location_gnss.cpp +++ b/gnss/location_gnss.cpp @@ -253,6 +253,6 @@ static void getDebugReport(GnssDebugReport& report) { static void updateConnectionStatus(bool connected, uint8_t type) { if (NULL != gGnssAdapter) { - gGnssAdapter->updateConnectionStatusCommand(connected, type); + gGnssAdapter->getSystemStatus()->eventConnectionStatus(connected, type); } } \ No newline at end of file From f0d7fe810f46662ae3d876b7b47540c24211be2b Mon Sep 17 00:00:00 2001 From: Harikrishnan Hariharan Date: Mon, 4 Sep 2017 11:55:13 +0530 Subject: [PATCH 6/8] Xtra client interfacing with LocNetIface in LE Interfacing LocnetIface with Xtra client for wwan/supl call setup and teardown. - XtraSystemStatusObserver must listen to connect/teardown wwan call requests from xtra-daemon on the HAL side socket. This request is then processed by libloc_net_iface module on LE. - Caching the connect and disconnect backhaul requests received before framework action request object is obtained. Change-Id: I7cb6751efc64b27726b5d28be9a3df7b1bfb3d76 CRs-Fixed: 2092215 --- core/Makefile.am | 1 + core/SystemStatusOsObserver.cpp | 62 ++++++++++++++ core/SystemStatusOsObserver.h | 14 ++++ core/observer/IFrameworkActionReq.h | 18 ++++ core/observer/IOsObserver.h | 4 + gnss/XtraSystemStatusObserver.cpp | 124 ++++++++++++++++++++++++++++ gnss/XtraSystemStatusObserver.h | 67 +++++++++++++++ 7 files changed, 290 insertions(+) diff --git a/core/Makefile.am b/core/Makefile.am index 42586686..92aaded0 100644 --- a/core/Makefile.am +++ b/core/Makefile.am @@ -1,5 +1,6 @@ AM_CFLAGS = -I./ \ -I../utils \ + -I../gnss \ -I../location \ -I./data-items \ -I./data-items/common \ diff --git a/core/SystemStatusOsObserver.cpp b/core/SystemStatusOsObserver.cpp index 319f1d7a..dc08a76e 100644 --- a/core/SystemStatusOsObserver.cpp +++ b/core/SystemStatusOsObserver.cpp @@ -41,6 +41,9 @@ namespace loc_core { SystemStatusOsObserver::SystemStatusOsObserver(const MsgTask* msgTask) : mAddress("SystemStatusOsObserver"), +#ifdef USE_GLIB + mBackHaulConnectReqCount(0), +#endif mClientIndex(IndexFactory :: createClientIndex()), mDataItemIndex(IndexFactory :: createDataItemIndex()) { @@ -506,6 +509,65 @@ void SystemStatusOsObserver::turnOff(DataItemId dit) } } +#ifdef USE_GLIB +bool SystemStatusOsObserver::connectBackhaul() +{ + bool result = false; + + if (mContext.mFrameworkActionReqObj != NULL) { + struct HandleConnectBackhaul : public LocMsg { + HandleConnectBackhaul(IFrameworkActionReq* fwkActReq) : + mFwkActionReqObj(fwkActReq) {} + virtual ~HandleConnectBackhaul() {} + void proc() const { + LOC_LOGD("HandleConnectBackhaul"); + mFwkActionReqObj->connectBackhaul(); + } + IFrameworkActionReq* mFwkActionReqObj; + }; + mContext.mMsgTask->sendMsg( + new (nothrow) HandleConnectBackhaul(mContext.mFrameworkActionReqObj)); + result = true; + } + else { + ++mBackHaulConnectReqCount; + LOC_LOGE("Framework action request object is NULL.Caching connect request: %d", + mBackHaulConnectReqCount); + result = false; + } + return result; + +} + +bool SystemStatusOsObserver::disconnectBackhaul() +{ + bool result = false; + + if (mContext.mFrameworkActionReqObj != NULL) { + struct HandleDisconnectBackhaul : public LocMsg { + HandleDisconnectBackhaul(IFrameworkActionReq* fwkActReq) : + mFwkActionReqObj(fwkActReq) {} + virtual ~HandleDisconnectBackhaul() {} + void proc() const { + LOC_LOGD("HandleDisconnectBackhaul"); + mFwkActionReqObj->disconnectBackhaul(); + } + IFrameworkActionReq* mFwkActionReqObj; + }; + mContext.mMsgTask->sendMsg( + new (nothrow) HandleDisconnectBackhaul(mContext.mFrameworkActionReqObj)); + } + else { + if (mBackHaulConnectReqCount > 0) { + --mBackHaulConnectReqCount; + } + LOC_LOGE("Framework action request object is NULL.Caching disconnect request: %d", + mBackHaulConnectReqCount); + result = false; + } + return result; +} +#endif /****************************************************************************** Helpers ******************************************************************************/ diff --git a/core/SystemStatusOsObserver.h b/core/SystemStatusOsObserver.h index 985e5c99..6892f226 100644 --- a/core/SystemStatusOsObserver.h +++ b/core/SystemStatusOsObserver.h @@ -85,6 +85,12 @@ public: // To set the framework action request object inline void setFrameworkActionReqObj(IFrameworkActionReq* frameworkActionReqObj) { mContext.mFrameworkActionReqObj = frameworkActionReqObj; +#ifdef USE_GLIB + if (mBackHaulConnectReqCount > 0) { + connectBackhaul(); + mBackHaulConnectReqCount = 0; + } +#endif } // IDataItemSubscription Overrides @@ -103,6 +109,10 @@ public: // IFrameworkActionReq Overrides virtual void turnOn(DataItemId dit, int timeOut = 0); virtual void turnOff(DataItemId dit); +#ifdef USE_GLIB + virtual bool connectBackhaul(); + virtual bool disconnectBackhaul(); +#endif private: SystemContext mContext; @@ -117,6 +127,10 @@ private: ObserverReqCache mReqDataCache; void cacheObserverRequest(ObserverReqCache& reqCache, const list& l, IDataItemObserver* client); +#ifdef USE_GLIB + // Cache the framework action request for connect/disconnect + int mBackHaulConnectReqCount; +#endif // Helpers void sendFirstResponse(const list& l, IDataItemObserver* to); diff --git a/core/observer/IFrameworkActionReq.h b/core/observer/IFrameworkActionReq.h index c7b3ebdc..4be947ff 100644 --- a/core/observer/IFrameworkActionReq.h +++ b/core/observer/IFrameworkActionReq.h @@ -70,6 +70,24 @@ public: */ virtual void turnOff (DataItemId dit) = 0; +#ifdef USE_GLIB + /** + * @brief Setup WWAN backhaul + * @details Setup WWAN backhaul + * + * @param None + */ + virtual bool connectBackhaul() = 0; + + /** + * @brief Disconnects the WWANbackhaul + * @details Disconnects the WWANbackhaul, only if it was setup by us + * + * @param None + */ + virtual bool disconnectBackhaul() = 0; +#endif + /** * @brief Destructor * @details Destructor diff --git a/core/observer/IOsObserver.h b/core/observer/IOsObserver.h index 3db8a85e..40d76717 100644 --- a/core/observer/IOsObserver.h +++ b/core/observer/IOsObserver.h @@ -90,6 +90,10 @@ public: // IFrameworkActionReq Overrides inline virtual void turnOn (DataItemId /*dit*/, int /*timeOut*/){} inline virtual void turnOff (DataItemId /*dit*/) {} +#ifdef USE_GLIB + inline virtual bool connectBackhaul() {} + inline virtual bool disconnectBackhaul() {} +#endif /** * @brief Destructor diff --git a/gnss/XtraSystemStatusObserver.cpp b/gnss/XtraSystemStatusObserver.cpp index ce08f648..ac402207 100644 --- a/gnss/XtraSystemStatusObserver.cpp +++ b/gnss/XtraSystemStatusObserver.cpp @@ -231,4 +231,128 @@ void XtraSystemStatusObserver::notify(const list& dlist) mMsgTask->sendMsg(new (nothrow) handleOsObserverUpdateMsg(this, dlist)); } +#ifdef USE_GLIB +bool XtraSystemStatusObserver::connectBackhaul() +{ + return mSystemStatusObsrvr->connectBackhaul(); +} +bool XtraSystemStatusObserver::disconnectBackhaul() +{ + return mSystemStatusObsrvr->disconnectBackhaul(); +} + +// XtraHalListenerSocket class +// TBD - this will be removed once bidirectional socket changes in +// xtra-daemon will be implemented +void XtraHalListenerSocket::receiveData(const int socketFd) { + string data; + array buf; + const char* bin_msg_conn_backhaul = "connectBackhaul"; + const char* bin_msg_disconn_backhaul = "disconnectBackhaul"; + + while (true) { + ssize_t len = recv(socketFd, buf.data(), buf.size(), 0); + if (len > 0) { + LOC_LOGd("received %lu bytes", len); + data.append(buf.data(), len); + + size_t pos = data.find("\n"); + if (pos == string::npos) { + continue; + } + + if (!strncmp(data.c_str(), bin_msg_conn_backhaul, + sizeof(bin_msg_conn_backhaul) - 1)) { + mSystemStatusObsrvr->connectBackhaul(); + } else if (!strncmp(data.c_str(), bin_msg_disconn_backhaul, + sizeof(bin_msg_disconn_backhaul) - 1)) { + mSystemStatusObsrvr->disconnectBackhaul(); + } + else { + LOC_LOGw("unknown event: %s", data.c_str()); + } + break; + + } else { + LOC_LOGd("XtraHalListenerSocket connection broken."); + break; + } + } +} + +void XtraHalListenerSocket::startListenerThread() { + mThread = new (std::nothrow) LocThread(); + if (!mThread) { + LOC_LOGe("create thread failed"); + } + mRunning = true; + if (!mThread->start("XtraHalListenerSocketThread", this, true)) { + delete mThread; + mThread = NULL; + } + + LOC_LOGd("Create listener socket in XtraHalListenerSocket"); + // create socket + int socketFd; + if ((socketFd = ::socket(AF_UNIX, SOCK_STREAM, 0)) < 0) { + LOC_LOGe("create socket error. reason:%s", strerror(errno)); + return; + } + + const char* socketPath = "/data/vendor/location/xtra/socket_xtra_locnetiface"; + unlink(socketPath); + + struct sockaddr_un addr = { .sun_family = AF_UNIX }; + snprintf(addr.sun_path, sizeof(addr.sun_path), "%s", socketPath); + + umask(0157); + + if (::bind(socketFd, (struct sockaddr*)&addr, sizeof(addr)) < 0) { + LOC_LOGe("bind socket error. reason:%s", strerror(errno)); + return; + } + + // set up connection + if (::listen(socketFd, 5/*backlog*/) < 0) { + LOC_LOGe("cannot bind socket. reason:%s", strerror(errno)); + return; + } + mSocketFd = socketFd; + +} + +bool XtraHalListenerSocket::run() { + // infinite while loop till mRunning is false when stopListenXtraDaemon + // is called + while (mRunning) { + int clientFd = -1; + LOC_LOGd("XtraHalListenerSocket - waiting for msg..."); + if ( (clientFd = ::accept(mSocketFd, NULL, NULL)) < 0) { + LOC_LOGe("connection error. reason:%s", strerror(errno)); + } else { + LOC_LOGd("XtraHalListenerSocket - receiving data ..."); + receiveData(clientFd); + if (::close(clientFd)) { + LOC_LOGe("close connection fail."); + } + clientFd = -1; + } + } + + // return false once we reach there + return false; +} + +void XtraHalListenerSocket::stopListenXtraDaemon() { + if (mSocketFd >= 0) { + if (::close(mSocketFd)) { + LOC_LOGe("close hal connection fail."); + } + mSocketFd = -1; + } + mRunning = false; + mThread->stop(); +} + +#endif diff --git a/gnss/XtraSystemStatusObserver.h b/gnss/XtraSystemStatusObserver.h index 42f49b53..6a001d9f 100644 --- a/gnss/XtraSystemStatusObserver.h +++ b/gnss/XtraSystemStatusObserver.h @@ -31,17 +31,72 @@ #include #include +#ifdef USE_GLIB +#include +#endif using namespace std; using loc_core::IOsObserver; using loc_core::IDataItemObserver; using loc_core::IDataItemCore; +#ifdef USE_GLIB +// XtraHalListenerSocket class +// listener socket for getting msgs from xtra-daemon in LE for invoking +// LocNetIface functions +// TBD - this will be removed once bidirectional socket changes in +// xtra-daemon will be implemented +class XtraHalListenerSocket: public LocRunnable { +public : + // constructor & destructor + XtraHalListenerSocket(IOsObserver* sysStatObs) : + mThread(NULL), + mRunning(false) { + mSystemStatusObsrvr = sysStatObs; + mRunning = true; + // create listener socket in a thread + startListenerThread(); + } + XtraHalListenerSocket() {} + inline virtual ~XtraHalListenerSocket() { + if (mThread) { + stopListenXtraDaemon(); + delete mThread; + mThread = NULL; + } + } + + // Overrides of LocRunnable methods + // This method will be repeated called until it returns false; or + // until thread is stopped. + virtual bool run(); + + // The method to be run before thread loop (conditionally repeatedly) + // calls run() + inline virtual void prerun() {} + + // The method to be run after thread loop (conditionally repeatedly) + // calls run() + inline virtual void postrun() {} + +private: + IOsObserver* mSystemStatusObsrvr; + int mSocketFd; + LocThread* mThread; + bool mRunning; + void startListenerThread(); + void stopListenXtraDaemon(); + void receiveData(const int socketFd); +}; +#endif class XtraSystemStatusObserver : public IDataItemObserver { public : // constructor & destructor inline XtraSystemStatusObserver(IOsObserver* sysStatObs, const MsgTask* msgTask): +#ifdef USE_GLIB + mHalListenerSocket(sysStatObs), +#endif mSystemStatusObsrvr(sysStatObs), mMsgTask(msgTask) { subscribe(true); } @@ -52,6 +107,12 @@ public : inline virtual void getName(string& name); virtual void notify(const list& dlist); +#ifdef USE_GLIB + // IFrameworkActionReq functions reqd + virtual bool connectBackhaul(); + virtual bool disconnectBackhaul(); +#endif + bool updateLockStatus(uint32_t lock); bool updateConnectionStatus(bool connected, uint32_t type); bool updateTac(const string& tac); @@ -65,6 +126,12 @@ private: bool sendEvent(const stringstream& event); IOsObserver* mSystemStatusObsrvr; const MsgTask* mMsgTask; +#ifdef USE_GLIB + // XtraHalListenerSocket class + // TBD - this will be removed once bidirectional socket changes in + // xtra-daemon will be implemented + XtraHalListenerSocket mHalListenerSocket; +#endif }; From 4d8fc57928cf6a5acfdcd666b4ee25a586cb2bc1 Mon Sep 17 00:00:00 2001 From: Katz Yamada Date: Fri, 4 Aug 2017 11:20:16 -0700 Subject: [PATCH 7/8] Fix unable to clear existing event bitmasks Fix for an issue updateEvtMask call chain is unable to clear existing event bitmasks stored in LocApiV02. Change-Id: Id34e2d92a506e7300f3d9b3ec74a80a1f6822787 CRs-Fixed: 2085379 --- core/LocApiBase.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/LocApiBase.cpp b/core/LocApiBase.cpp index e0845de2..070b2ae5 100644 --- a/core/LocApiBase.cpp +++ b/core/LocApiBase.cpp @@ -164,7 +164,7 @@ void LocApiBase::addAdapter(LocAdapterBase* adapter) if (mLocAdapters[i] == NULL) { mLocAdapters[i] = adapter; mMsgTask->sendMsg(new LocOpenMsg(this, - (adapter->getEvtMask()))); + mMask | adapter->getEvtMask())); break; } } From 40284224df2adc2bcf9ac4a96031352038daa82d Mon Sep 17 00:00:00 2001 From: Harikrishnan Hariharan Date: Tue, 5 Sep 2017 17:52:32 +0530 Subject: [PATCH 8/8] Transition of base DataConcreteType class to HAL Transition of base DataConcreteType class to HAL, so that modules in HAL can access the members of DataItem class. Change-Id: Ib3b60992cf35a52b601117d5d18761d759f31b86 CRs-Fixed: 2104384 --- core/Makefile.am | 1 + core/SystemStatus.cpp | 3 +- core/data-items/DataItemConcreteTypesBase.h | 446 ++++++++++++++++++++ gnss/XtraSystemStatusObserver.cpp | 11 +- 4 files changed, 456 insertions(+), 5 deletions(-) create mode 100644 core/data-items/DataItemConcreteTypesBase.h diff --git a/core/Makefile.am b/core/Makefile.am index 92aaded0..81ef2ee7 100644 --- a/core/Makefile.am +++ b/core/Makefile.am @@ -23,6 +23,7 @@ libloc_core_la_h_sources = \ LocAdapterProxyBase.h \ data-items/DataItemId.h \ data-items/IDataItemCore.h \ + data-items/DataItemConcreteTypesBase.h \ observer/IDataItemObserver.h \ observer/IDataItemSubscription.h \ observer/IFrameworkActionReq.h \ diff --git a/core/SystemStatus.cpp b/core/SystemStatus.cpp index 52d28c7a..c83a7d00 100644 --- a/core/SystemStatus.cpp +++ b/core/SystemStatus.cpp @@ -40,6 +40,7 @@ #include #include #include +#include namespace loc_core { @@ -1420,7 +1421,7 @@ bool SystemStatus::setPositionFailure(const SystemStatusPQWS1& nmea) ******************************************************************************/ bool SystemStatus::setNetworkInfo(IDataItemCore* dataitem) { - SystemStatusNetworkInfo* data = reinterpret_cast(dataitem); + NetworkInfoDataItemBase* data = reinterpret_cast(dataitem); SystemStatusNetworkInfo s(data->mType,data->mTypeName,data->mSubTypeName, data->mAvailable,data->mConnected,data->mRoaming); s.dump(); diff --git a/core/data-items/DataItemConcreteTypesBase.h b/core/data-items/DataItemConcreteTypesBase.h new file mode 100644 index 00000000..74722d06 --- /dev/null +++ b/core/data-items/DataItemConcreteTypesBase.h @@ -0,0 +1,446 @@ +/* Copyright (c) 2015-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 __DATAITEMCONCRETEBASETYPES__ +#define __DATAITEMCONCRETEBASETYPES__ + +#include +#include +#include +#include + +#define MAC_ADDRESS_LENGTH 6 +// MAC address length in bytes +// QMI_LOC_SRN_MAC_ADDR_LENGTH_V02 +#define SRN_MAC_ADDRESS_LENGTH 6 +#define WIFI_SUPPLICANT_DEFAULT_STATE 0 + +namespace loc_core +{ +using namespace std; + +class AirplaneModeDataItemBase : public IDataItemCore { +public: + AirplaneModeDataItemBase(bool mode): + mMode(mode), + mId(AIRPLANEMODE_DATA_ITEM_ID) {} + virtual ~AirplaneModeDataItemBase() {} + inline virtual DataItemId getId() { return mId; } + virtual void stringify(string& /*valueStr*/) {} + virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;} +// Data members + bool mMode; + +protected: + DataItemId mId; +}; + +class ENHDataItemBase : public IDataItemCore { +public: + ENHDataItemBase(bool enabled) : + mEnabled(enabled), + mId(ENH_DATA_ITEM_ID) {} + virtual ~ENHDataItemBase() {} + inline virtual DataItemId getId() { return mId; } + virtual void stringify(string& /*valueStr*/) {} + virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;} +// Data members + bool mEnabled; +protected: + DataItemId mId; +}; + +class GPSStateDataItemBase : public IDataItemCore { +public: + GPSStateDataItemBase(bool enabled) : + mEnabled(enabled), + mId(GPSSTATE_DATA_ITEM_ID) {} + virtual ~GPSStateDataItemBase() {} + inline virtual DataItemId getId() { return mId; } + virtual void stringify(string& /*valueStr*/) {} + virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;} +// Data members + bool mEnabled; +protected: + DataItemId mId; +}; + +class NLPStatusDataItemBase : public IDataItemCore { +public: + NLPStatusDataItemBase(bool enabled) : + mEnabled(enabled), + mId(NLPSTATUS_DATA_ITEM_ID) {} + virtual ~NLPStatusDataItemBase() {} + inline virtual DataItemId getId() { return mId; } + virtual void stringify(string& /*valueStr*/) {} + virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;} +// Data members + bool mEnabled; +protected: + DataItemId mId; +}; + +class WifiHardwareStateDataItemBase : public IDataItemCore { +public: + WifiHardwareStateDataItemBase(bool enabled) : + mEnabled(enabled), + mId(WIFIHARDWARESTATE_DATA_ITEM_ID) {} + virtual ~WifiHardwareStateDataItemBase() {} + inline virtual DataItemId getId() { return mId; } + virtual void stringify(string& /*valueStr*/) {} + virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;} +// Data members + bool mEnabled; +protected: + DataItemId mId; +}; + +class ScreenStateDataItemBase : public IDataItemCore { +public: + ScreenStateDataItemBase(bool state) : + mState(state), + mId(SCREEN_STATE_DATA_ITEM_ID) {} + virtual ~ScreenStateDataItemBase() {} + inline virtual DataItemId getId() { return mId; } + virtual void stringify(string& /*valueStr*/) {} + virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;} +// Data members + bool mState; +protected: + DataItemId mId; +}; + +class PowerConnectStateDataItemBase : public IDataItemCore { +public: + PowerConnectStateDataItemBase(bool state) : + mState(state), + mId(POWER_CONNECTED_STATE_DATA_ITEM_ID) {} + virtual ~PowerConnectStateDataItemBase() {} + inline virtual DataItemId getId() { return mId; } + virtual void stringify(string& /*valueStr*/) {} + virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;} +// Data members + bool mState; +protected: + DataItemId mId; +}; + +class TimeZoneChangeDataItemBase : public IDataItemCore { +public: + TimeZoneChangeDataItemBase(int64_t currTimeMillis, int32_t rawOffset, int32_t dstOffset) : + mCurrTimeMillis (currTimeMillis), + mRawOffsetTZ (rawOffset), + mDstOffsetTZ (dstOffset), + mId(TIMEZONE_CHANGE_DATA_ITEM_ID) {} + virtual ~TimeZoneChangeDataItemBase() {} + inline virtual DataItemId getId() { return mId; } + virtual void stringify(string& /*valueStr*/) {} + virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;} +// Data members + int64_t mCurrTimeMillis; + int32_t mRawOffsetTZ; + int32_t mDstOffsetTZ; +protected: + DataItemId mId; +}; + +class TimeChangeDataItemBase : public IDataItemCore { +public: + TimeChangeDataItemBase(int64_t currTimeMillis, int32_t rawOffset, int32_t dstOffset) : + mCurrTimeMillis (currTimeMillis), + mRawOffsetTZ (rawOffset), + mDstOffsetTZ (dstOffset), + mId(TIME_CHANGE_DATA_ITEM_ID) {} + virtual ~TimeChangeDataItemBase() {} + inline virtual DataItemId getId() { return mId; } + virtual void stringify(string& /*valueStr*/) {} + virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;} +// Data members + int64_t mCurrTimeMillis; + int32_t mRawOffsetTZ; + int32_t mDstOffsetTZ; +protected: + DataItemId mId; +}; + +class ShutdownStateDataItemBase : public IDataItemCore { +public: + ShutdownStateDataItemBase(bool state) : + mState (state), + mId(SHUTDOWN_STATE_DATA_ITEM_ID) {} + virtual ~ShutdownStateDataItemBase() {} + inline virtual DataItemId getId() { return mId; } + virtual void stringify(string& /*valueStr*/) {} + virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;} +// Data members + bool mState; +protected: + DataItemId mId; +}; + +class AssistedGpsDataItemBase : public IDataItemCore { +public: + AssistedGpsDataItemBase(bool enabled) : + mEnabled(enabled), + mId(ASSISTED_GPS_DATA_ITEM_ID) {} + virtual ~AssistedGpsDataItemBase() {} + inline virtual DataItemId getId() { return mId; } + virtual void stringify(string& /*valueStr*/) {} + virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;} +// Data members + bool mEnabled; +protected: + DataItemId mId; +}; + +class NetworkInfoDataItemBase : public IDataItemCore { +public: + NetworkInfoDataItemBase( + int32_t type, string typeName, string subTypeName, + bool available, bool connected, bool roaming ): + mType(type), + mTypeName(typeName), + mSubTypeName(subTypeName), + mAvailable(available), + mConnected(connected), + mRoaming(roaming), + mId(NETWORKINFO_DATA_ITEM_ID) {} + virtual ~NetworkInfoDataItemBase() {} + inline virtual DataItemId getId() { return mId; } + virtual void stringify(string& /*valueStr*/) {} + virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;} +// Data members + int32_t mType; + string mTypeName; + string mSubTypeName; + bool mAvailable; + bool mConnected; + bool mRoaming; +protected: + DataItemId mId; + +}; + +class ServiceStatusDataItemBase : public IDataItemCore { +public: + ServiceStatusDataItemBase(int32_t serviceState) : + mServiceState (serviceState), + mId(SERVICESTATUS_DATA_ITEM_ID) {} + virtual ~ServiceStatusDataItemBase() {} + inline virtual DataItemId getId() { return mId; } + virtual void stringify(string& /*valueStr*/) {} + virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;} +// Data members + int32_t mServiceState; +protected: + DataItemId mId; +}; + +class ModelDataItemBase : public IDataItemCore { +public: + ModelDataItemBase(const string & name) : + mModel (name), + mId(MODEL_DATA_ITEM_ID) {} + virtual ~ModelDataItemBase() {} + inline virtual DataItemId getId() { return mId; } + virtual void stringify(string& /*valueStr*/) {} + virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;} +// Data members + string mModel; +protected: + DataItemId mId; +}; + +class ManufacturerDataItemBase : public IDataItemCore { +public: + ManufacturerDataItemBase(const string & name) : + mManufacturer (name), + mId(MANUFACTURER_DATA_ITEM_ID) {} + virtual ~ManufacturerDataItemBase() {} + inline virtual DataItemId getId() { return mId; } + virtual void stringify(string& /*valueStr*/) {} + virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;} +// Data members + string mManufacturer; +protected: + DataItemId mId; +}; + +class RilServiceInfoDataItemBase : public IDataItemCore { +public: + RilServiceInfoDataItemBase() : + mId(RILSERVICEINFO_DATA_ITEM_ID) {} + virtual ~RilServiceInfoDataItemBase() {} + inline virtual DataItemId getId() { return mId; } + virtual void stringify(string& /*valueStr*/) {} + virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;} +protected: + DataItemId mId; +}; + +class RilCellInfoDataItemBase : public IDataItemCore { +public: + RilCellInfoDataItemBase() : + mId(RILCELLINFO_DATA_ITEM_ID) {} + virtual ~RilCellInfoDataItemBase() {} + inline virtual DataItemId getId() { return mId; } + virtual void stringify(string& /*valueStr*/) {} + virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;} +protected: + DataItemId mId; +}; + +class WifiSupplicantStatusDataItemBase : public IDataItemCore { +public: + WifiSupplicantStatusDataItemBase() : + mState((WifiSupplicantState)WIFI_SUPPLICANT_DEFAULT_STATE), + mApMacAddressValid(false), + mWifiApSsidValid(false), + mId(WIFI_SUPPLICANT_STATUS_DATA_ITEM_ID) { + memset (&mApMacAddress, 0, sizeof (mApMacAddress)); + mWifiApSsid.clear(); + } + virtual ~WifiSupplicantStatusDataItemBase() {} + inline virtual DataItemId getId() { return mId; } + virtual void stringify(string& /*valueStr*/) {} + virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;} + // Data members + typedef enum WifiSupplicantState { + DISCONNECTED, + INTERFACE_DISABLED, + INACTIVE, + SCANNING, + AUTHENTICATING, + ASSOCIATING, + ASSOCIATED, + FOUR_WAY_HANDSHAKE, + GROUP_HANDSHAKE, + COMPLETED, + DORMANT, + UNINITIALIZED, + INVALID + } WifiSupplicantState; + /* Represents whether access point attach state*/ + WifiSupplicantState mState; + /* Represents info on whether ap mac address is valid */ + bool mApMacAddressValid; + /* Represents mac address of the wifi access point*/ + uint8_t mApMacAddress[MAC_ADDRESS_LENGTH]; + /* Represents info on whether ap SSID is valid */ + bool mWifiApSsidValid; + /* Represents Wifi SSID string*/ + string mWifiApSsid; +protected: + DataItemId mId; +}; + +class TacDataItemBase : public IDataItemCore { +public: + TacDataItemBase(const string & name) : + mValue (name), + mId(TAC_DATA_ITEM_ID) {} + virtual ~TacDataItemBase() {} + inline virtual DataItemId getId() { return mId; } + virtual void stringify(string& /*valueStr*/) {} + virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;} +// Data members + string mValue; +protected: + DataItemId mId; +}; + +class MccmncDataItemBase : public IDataItemCore { +public: + MccmncDataItemBase(const string & name) : + mValue (name), + mId(MCCMNC_DATA_ITEM_ID) {} + virtual ~MccmncDataItemBase() {} + inline virtual DataItemId getId() { return mId; } + virtual void stringify(string& /*valueStr*/) {} + virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;} +// Data members + string mValue; +protected: + DataItemId mId; +}; + +class SrnDeviceScanDetailsDataItemBase : public IDataItemCore { +public: + SrnDeviceScanDetailsDataItemBase (DataItemId Id) : + mValidSrnData(false), + mApSrnRssi(-1), + mApSrnTimestamp(0), + mRequestTimestamp(0), + mReceiveTimestamp(0), + mErrorCause(-1), + mId(Id) {} + virtual ~SrnDeviceScanDetailsDataItemBase () {} + inline virtual DataItemId getId() { return mId; } + // Data members common to all SRN tech types + /* Represents info on whether SRN data is valid (no error)*/ + bool mValidSrnData; + /* SRN device RSSI reported */ + int32_t mApSrnRssi; + /* MAC adress of SRN device */ + uint8_t mApSrnMacAddress[SRN_MAC_ADDRESS_LENGTH]; + /* UTC timestamp at which the scan was requested.for this SRN device*/ + int64_t mApSrnTimestamp; + /* UTC timestamp at which the scan was started. */ + int64_t mRequestTimestamp; + /* UTC timestamp at which the scan was received.*/ + int64_t mReceiveTimestamp; + /* Reason for the error/failure if SRN details are not valid */ + int32_t mErrorCause; +protected: + DataItemId mId; +}; + +class BtDeviceScanDetailsDataItemBase : public SrnDeviceScanDetailsDataItemBase { + +public: + BtDeviceScanDetailsDataItemBase() : + SrnDeviceScanDetailsDataItemBase(BT_SCAN_DATA_ITEM_ID) {} + virtual ~BtDeviceScanDetailsDataItemBase() {} + virtual void stringify(string& /*valueStr*/) {} + virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;} +}; + +class BtLeDeviceScanDetailsDataItemBase : public SrnDeviceScanDetailsDataItemBase { + +public: + BtLeDeviceScanDetailsDataItemBase() : + SrnDeviceScanDetailsDataItemBase(BTLE_SCAN_DATA_ITEM_ID) {} + virtual ~BtLeDeviceScanDetailsDataItemBase() {} + virtual void stringify(string& /*valueStr*/) {} + virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;} +}; + +} // namespace loc_core + +#endif //__DATAITEMCONCRETEBASETYPES__ diff --git a/gnss/XtraSystemStatusObserver.cpp b/gnss/XtraSystemStatusObserver.cpp index ac402207..bbbc19ae 100644 --- a/gnss/XtraSystemStatusObserver.cpp +++ b/gnss/XtraSystemStatusObserver.cpp @@ -47,6 +47,7 @@ #include #include #include +#include using namespace loc_core; @@ -201,8 +202,8 @@ void XtraSystemStatusObserver::notify(const list& dlist) { case NETWORKINFO_DATA_ITEM_ID: { - SystemStatusNetworkInfo* networkInfo = - reinterpret_cast(each); + NetworkInfoDataItemBase* networkInfo = + static_cast(each); mXtraSysStatObj->updateConnectionStatus(networkInfo->mConnected, networkInfo->mType); } @@ -210,14 +211,16 @@ void XtraSystemStatusObserver::notify(const list& dlist) case TAC_DATA_ITEM_ID: { - SystemStatusTac* tac = reinterpret_cast(each); + TacDataItemBase* tac = + static_cast(each); mXtraSysStatObj->updateTac(tac->mValue); } break; case MCCMNC_DATA_ITEM_ID: { - SystemStatusMccMnc* mccmnc = reinterpret_cast(each); + MccmncDataItemBase* mccmnc = + static_cast(each); mXtraSysStatObj->updateMccMnc(mccmnc->mValue); } break;