msm8996-common: Update GPS HIDL HAL from upstream

 * Tag: LA.UM.6.6.r1-06700-89xx.0

Change-Id: If746b12bcbc3e414aa9ba9f421040edd0f815638

5 files changed, 1094 insertions, 559 deletions

diff --git a/gps/core/SystemStatus.cpp b/gps/core/SystemStatus.cpp
index 52d28c7..92ddeed 100644
--- a/gps/core/SystemStatus.cpp
+++ b/gps/core/SystemStatus.cpp
@@ -40,6 +40,7 @@
 #include <DataItemsFactoryProxy.h>
 #include <SystemStatus.h>
 #include <SystemStatusOsObserver.h>
+#include <DataItemConcreteTypesBase.h>
 
 namespace loc_core
 {
@@ -150,6 +151,7 @@ private:
         eAgcGlo = 20,
         eAgcBds = 21,
         eAgcGal = 22,
+        eMax0 = eAgcGal,
         eLeapSeconds = 23,
         eLeapSecUnc = 24,
         eMax
@@ -186,7 +188,7 @@ public:
         : SystemStatusNmeaBase(str_in, len_in)
     {
         memset(&mM1, 0, sizeof(mM1));
-        if (mField.size() < eMax) {
+        if (mField.size() <= eMax0) {
             LOC_LOGE("PQWM1parser - invalid size=%zu", mField.size());
             mM1.mTimeValid = 0;
             return;
@@ -213,8 +215,10 @@ public:
         mM1.mAgcGlo = atof(mField[eAgcGlo].c_str());
         mM1.mAgcBds = atof(mField[eAgcBds].c_str());
         mM1.mAgcGal = atof(mField[eAgcGal].c_str());
-        mM1.mLeapSeconds = atoi(mField[eLeapSeconds].c_str());
-        mM1.mLeapSecUnc = atoi(mField[eLeapSecUnc].c_str());
+        if (mField.size() > eLeapSecUnc) {
+            mM1.mLeapSeconds = atoi(mField[eLeapSeconds].c_str());
+            mM1.mLeapSecUnc = atoi(mField[eLeapSecUnc].c_str());
+        }
     }
 
     inline SystemStatusPQWM1& get() { return mM1;} //getparser
@@ -689,7 +693,7 @@ SystemStatusTimeAndClock::SystemStatusTimeAndClock(const SystemStatusPQWM1& nmea
 {
 }
 
-bool SystemStatusTimeAndClock::equals(SystemStatusTimeAndClock& peer)
+bool SystemStatusTimeAndClock::equals(const SystemStatusTimeAndClock& peer)
 {
     if ((mGpsWeek != peer.mGpsWeek) ||
         (mGpsTowMs != peer.mGpsTowMs) ||
@@ -729,7 +733,7 @@ SystemStatusXoState::SystemStatusXoState(const SystemStatusPQWM1& nmea) :
 {
 }
 
-bool SystemStatusXoState::equals(SystemStatusXoState& peer)
+bool SystemStatusXoState::equals(const SystemStatusXoState& peer)
 {
     if (mXoState != peer.mXoState) {
         return false;
@@ -765,7 +769,7 @@ SystemStatusRfAndParams::SystemStatusRfAndParams(const SystemStatusPQWM1& nmea)
 {
 }
 
-bool SystemStatusRfAndParams::equals(SystemStatusRfAndParams& peer)
+bool SystemStatusRfAndParams::equals(const SystemStatusRfAndParams& peer)
 {
     if ((mPgaGain != peer.mPgaGain) ||
         (mGpsBpAmpI != peer.mGpsBpAmpI) ||
@@ -815,7 +819,7 @@ SystemStatusErrRecovery::SystemStatusErrRecovery(const SystemStatusPQWM1& nmea)
 {
 }
 
-bool SystemStatusErrRecovery::equals(SystemStatusErrRecovery& peer)
+bool SystemStatusErrRecovery::equals(const SystemStatusErrRecovery& peer)
 {
     if (mRecErrorRecovery != peer.mRecErrorRecovery) {
         return false;
@@ -845,7 +849,7 @@ SystemStatusInjectedPosition::SystemStatusInjectedPosition(const SystemStatusPQW
 {
 }
 
-bool SystemStatusInjectedPosition::equals(SystemStatusInjectedPosition& peer)
+bool SystemStatusInjectedPosition::equals(const SystemStatusInjectedPosition& peer)
 {
     if ((mEpiValidity != peer.mEpiValidity) ||
         (mEpiLat != peer.mEpiLat) ||
@@ -886,7 +890,7 @@ SystemStatusBestPosition::SystemStatusBestPosition(const SystemStatusPQWP2& nmea
 {
 }
 
-bool SystemStatusBestPosition::equals(SystemStatusBestPosition& peer)
+bool SystemStatusBestPosition::equals(const SystemStatusBestPosition& peer)
 {
     if ((mBestLat != peer.mBestLat) ||
         (mBestLon != peer.mBestLon) ||
@@ -928,7 +932,7 @@ SystemStatusXtra::SystemStatusXtra(const SystemStatusPQWP3& nmea) :
 {
 }
 
-bool SystemStatusXtra::equals(SystemStatusXtra& peer)
+bool SystemStatusXtra::equals(const SystemStatusXtra& peer)
 {
     if ((mXtraValidMask != peer.mXtraValidMask) ||
         (mGpsXtraAge != peer.mGpsXtraAge) ||
@@ -976,7 +980,7 @@ SystemStatusEphemeris::SystemStatusEphemeris(const SystemStatusPQWP4& nmea) :
 {
 }
 
-bool SystemStatusEphemeris::equals(SystemStatusEphemeris& peer)
+bool SystemStatusEphemeris::equals(const SystemStatusEphemeris& peer)
 {
     if ((mGpsEpheValid != peer.mGpsEpheValid) ||
         (mGloEpheValid != peer.mGloEpheValid) ||
@@ -1022,7 +1026,7 @@ SystemStatusSvHealth::SystemStatusSvHealth(const SystemStatusPQWP5& nmea) :
 {
 }
 
-bool SystemStatusSvHealth::equals(SystemStatusSvHealth& peer)
+bool SystemStatusSvHealth::equals(const SystemStatusSvHealth& peer)
 {
     if ((mGpsUnknownMask != peer.mGpsUnknownMask) ||
         (mGloUnknownMask != peer.mGloUnknownMask) ||
@@ -1077,7 +1081,7 @@ SystemStatusPdr::SystemStatusPdr(const SystemStatusPQWP6& nmea) :
 {
 }
 
-bool SystemStatusPdr::equals(SystemStatusPdr& peer)
+bool SystemStatusPdr::equals(const SystemStatusPdr& peer)
 {
     if (mFixInfoMask != peer.mFixInfoMask) {
         return false;
@@ -1103,7 +1107,7 @@ SystemStatusNavData::SystemStatusNavData(const SystemStatusPQWP7& nmea)
     }
 }
 
-bool SystemStatusNavData::equals(SystemStatusNavData& peer)
+bool SystemStatusNavData::equals(const SystemStatusNavData& peer)
 {
     for (uint32_t i=0; i<SV_ALL_NUM; i++) {
         if ((mNav[i].mType != peer.mNav[i].mType) ||
@@ -1135,7 +1139,7 @@ SystemStatusPositionFailure::SystemStatusPositionFailure(const SystemStatusPQWS1
 {
 }
 
-bool SystemStatusPositionFailure::equals(SystemStatusPositionFailure& peer)
+bool SystemStatusPositionFailure::equals(const SystemStatusPositionFailure& peer)
 {
     if ((mFixInfoMask != peer.mFixInfoMask) ||
         (mHepeLimit != peer.mHepeLimit)) {
@@ -1156,7 +1160,7 @@ void SystemStatusPositionFailure::dump()
 /******************************************************************************
  SystemStatusLocation
 ******************************************************************************/
-bool SystemStatusLocation::equals(SystemStatusLocation& peer)
+bool SystemStatusLocation::equals(const SystemStatusLocation& peer)
 {
     if ((mLocation.gpsLocation.latitude != peer.mLocation.gpsLocation.latitude) ||
         (mLocation.gpsLocation.longitude != peer.mLocation.gpsLocation.longitude) ||
@@ -1213,7 +1217,7 @@ IOsObserver* SystemStatus::getOsObserver()
 }
 
 SystemStatus::SystemStatus(const MsgTask* msgTask) :
-    mSysStatusObsvr(msgTask),
+    mSysStatusObsvr(this, msgTask),
     mConnected(false)
 {
     int result = 0;
@@ -1235,206 +1239,76 @@ SystemStatus::SystemStatus(const MsgTask* msgTask) :
 
     mCache.mPositionFailure.clear();
 
-    EXIT_LOG_WITH_ERROR ("%d",result);
-}
-
-/******************************************************************************
- SystemStatus - M1 functions
-******************************************************************************/
-bool SystemStatus::setTimeAndCLock(const SystemStatusPQWM1& nmea)
-{
-    SystemStatusTimeAndClock s(nmea);
-    if (!mCache.mTimeAndClock.empty() && mCache.mTimeAndClock.back().equals(s)) {
-        mCache.mTimeAndClock.back().mUtcReported = s.mUtcReported;
-    } else {
-        mCache.mTimeAndClock.push_back(s);
-        if (mCache.mTimeAndClock.size() > maxTimeAndClock) {
-            mCache.mTimeAndClock.erase(mCache.mTimeAndClock.begin());
-        }
-    }
-    return true;
-}
-
-bool SystemStatus::setXoState(const SystemStatusPQWM1& nmea)
-{
-    SystemStatusXoState s(nmea);
-    if (!mCache.mXoState.empty() && mCache.mXoState.back().equals(s)) {
-        mCache.mXoState.back().mUtcReported = s.mUtcReported;
-    } else {
-        mCache.mXoState.push_back(s);
-        if (mCache.mXoState.size() > maxXoState) {
-            mCache.mXoState.erase(mCache.mXoState.begin());
-        }
-    }
-    return true;
-}
+    mCache.mAirplaneMode.clear();
+    mCache.mENH.clear();
+    mCache.mGPSState.clear();
+    mCache.mNLPStatus.clear();
+    mCache.mWifiHardwareState.clear();
+    mCache.mNetworkInfo.clear();
+    mCache.mRilServiceInfo.clear();
+    mCache.mRilCellInfo.clear();
+    mCache.mServiceStatus.clear();
+    mCache.mModel.clear();
+    mCache.mManufacturer.clear();
+    mCache.mAssistedGps.clear();
+    mCache.mScreenState.clear();
+    mCache.mPowerConnectState.clear();
+    mCache.mTimeZoneChange.clear();
+    mCache.mTimeChange.clear();
+    mCache.mWifiSupplicantStatus.clear();
+    mCache.mShutdownState.clear();
+    mCache.mTac.clear();
+    mCache.mMccMnc.clear();
+    mCache.mBtDeviceScanDetail.clear();
+    mCache.mBtLeDeviceScanDetail.clear();
 
-bool SystemStatus::setRfAndParams(const SystemStatusPQWM1& nmea)
-{
-    SystemStatusRfAndParams s(nmea);
-    if (!mCache.mRfAndParams.empty() && mCache.mRfAndParams.back().equals(s)) {
-        mCache.mRfAndParams.back().mUtcReported = s.mUtcReported;
-    } else {
-        mCache.mRfAndParams.push_back(s);
-        if (mCache.mRfAndParams.size() > maxRfAndParams) {
-            mCache.mRfAndParams.erase(mCache.mRfAndParams.begin());
-        }
-    }
-    return true;
-}
-
-bool SystemStatus::setErrRecovery(const SystemStatusPQWM1& nmea)
-{
-    SystemStatusErrRecovery s(nmea);
-    if (!mCache.mErrRecovery.empty() && mCache.mErrRecovery.back().equals(s)) {
-        mCache.mErrRecovery.back().mUtcReported = s.mUtcReported;
-    } else {
-        mCache.mErrRecovery.push_back(s);
-        if (mCache.mErrRecovery.size() > maxErrRecovery) {
-            mCache.mErrRecovery.erase(mCache.mErrRecovery.begin());
-        }
-    }
-    return true;
+    EXIT_LOG_WITH_ERROR ("%d",result);
 }
 
 /******************************************************************************
- SystemStatus - Px functions
+ SystemStatus - storing dataitems
 ******************************************************************************/
-bool SystemStatus::setInjectedPosition(const SystemStatusPQWP1& nmea)
-{
-    SystemStatusInjectedPosition s(nmea);
-    if (!mCache.mInjectedPosition.empty() && mCache.mInjectedPosition.back().equals(s)) {
-        mCache.mInjectedPosition.back().mUtcReported = s.mUtcReported;
-    } else {
-        mCache.mInjectedPosition.push_back(s);
-        if (mCache.mInjectedPosition.size() > maxInjectedPosition) {
-            mCache.mInjectedPosition.erase(mCache.mInjectedPosition.begin());
-        }
-    }
-    return true;
-}
-
-bool SystemStatus::setBestPosition(const SystemStatusPQWP2& nmea)
-{
-    SystemStatusBestPosition s(nmea);
-    if (!mCache.mBestPosition.empty() && mCache.mBestPosition.back().equals(s)) {
-        mCache.mBestPosition.back().mUtcReported = s.mUtcReported;
-    } else {
-        mCache.mBestPosition.push_back(s);
-        if (mCache.mBestPosition.size() > maxBestPosition) {
-            mCache.mBestPosition.erase(mCache.mBestPosition.begin());
-        }
-    }
-    return true;
-}
-
-bool SystemStatus::setXtra(const SystemStatusPQWP3& nmea)
+template <typename TYPE_SYSTEMSTATUS_ITEM, typename TYPE_REPORT, typename TYPE_ITEMBASE>
+bool SystemStatus::setItemBaseinReport(TYPE_REPORT& report, const TYPE_ITEMBASE& s)
 {
-    SystemStatusXtra s(nmea);
-    if (!mCache.mXtra.empty() && mCache.mXtra.back().equals(s)) {
-        mCache.mXtra.back().mUtcReported = s.mUtcReported;
-    } else {
-        mCache.mXtra.push_back(s);
-        if (mCache.mXtra.size() > maxXtra) {
-            mCache.mXtra.erase(mCache.mXtra.begin());
-        }
-    }
-    return true;
+    TYPE_SYSTEMSTATUS_ITEM sout(s);
+    return setIteminReport(report, sout);
 }
 
-bool SystemStatus::setEphemeris(const SystemStatusPQWP4& nmea)
+template <typename TYPE_REPORT, typename TYPE_ITEM>
+bool SystemStatus::setIteminReport(TYPE_REPORT& report, const TYPE_ITEM& s)
 {
-    SystemStatusEphemeris s(nmea);
-    if (!mCache.mEphemeris.empty() && mCache.mEphemeris.back().equals(s)) {
-        mCache.mEphemeris.back().mUtcReported = s.mUtcReported;
-    } else {
-        mCache.mEphemeris.push_back(s);
-        if (mCache.mEphemeris.size() > maxEphemeris) {
-            mCache.mEphemeris.erase(mCache.mEphemeris.begin());
-        }
+    if (!report.empty() && report.back().equals(s)) {
+        // there is no change - just update reported timestamp
+        report.back().mUtcReported = s.mUtcReported;
+        return false;
     }
-    return true;
-}
 
-bool SystemStatus::setSvHealth(const SystemStatusPQWP5& nmea)
-{
-    SystemStatusSvHealth s(nmea);
-    if (!mCache.mSvHealth.empty() && mCache.mSvHealth.back().equals(s)) {
-        mCache.mSvHealth.back().mUtcReported = s.mUtcReported;
-    } else {
-        mCache.mSvHealth.push_back(s);
-        if (mCache.mSvHealth.size() > maxSvHealth) {
-            mCache.mSvHealth.erase(mCache.mSvHealth.begin());
-        }
+    // first event or updated
+    report.push_back(s);
+    if (report.size() > s.maxItem) {
+        report.erase(report.begin());
     }
     return true;
 }
 
-bool SystemStatus::setPdr(const SystemStatusPQWP6& nmea)
+template <typename TYPE_REPORT, typename TYPE_ITEM>
+void SystemStatus::setDefaultIteminReport(TYPE_REPORT& report, const TYPE_ITEM& s)
 {
-    SystemStatusPdr s(nmea);
-    if (!mCache.mPdr.empty() && mCache.mPdr.back().equals(s)) {
-        mCache.mPdr.back().mUtcReported = s.mUtcReported;
-    } else {
-        mCache.mPdr.push_back(s);
-        if (mCache.mPdr.size() > maxPdr) {
-            mCache.mPdr.erase(mCache.mPdr.begin());
-        }
+    report.push_back(s);
+    if (report.size() > s.maxItem) {
+        report.erase(report.begin());
     }
-    return true;
 }
 
-bool SystemStatus::setNavData(const SystemStatusPQWP7& nmea)
+template <typename TYPE_REPORT, typename TYPE_ITEM>
+void SystemStatus::getIteminReport(TYPE_REPORT& reportout, const TYPE_ITEM& c) const
 {
-    SystemStatusNavData s(nmea);
-    if (!mCache.mNavData.empty() && mCache.mNavData.back().equals(s)) {
-        mCache.mNavData.back().mUtcReported = s.mUtcReported;
-    } else {
-        mCache.mNavData.push_back(s);
-        if (mCache.mNavData.size() > maxNavData) {
-            mCache.mNavData.erase(mCache.mNavData.begin());
-        }
+    reportout.clear();
+    if (c.size() >= 1) {
+        reportout.push_back(c.back());
+        reportout.back().dump();
     }
-    return true;
-}
-
-/******************************************************************************
- SystemStatus - Sx functions
-******************************************************************************/
-bool SystemStatus::setPositionFailure(const SystemStatusPQWS1& nmea)
-{
-    SystemStatusPositionFailure s(nmea);
-    if (!mCache.mPositionFailure.empty() && mCache.mPositionFailure.back().equals(s)) {
-        mCache.mPositionFailure.back().mUtcReported = s.mUtcReported;
-    } else {
-        mCache.mPositionFailure.push_back(s);
-        if (mCache.mPositionFailure.size() > maxPositionFailure) {
-            mCache.mPositionFailure.erase(mCache.mPositionFailure.begin());
-        }
-    }
-    return true;
-}
-
-/******************************************************************************
- SystemStatus - storing dataitems
-******************************************************************************/
-bool SystemStatus::setNetworkInfo(IDataItemCore* dataitem)
-{
-    SystemStatusNetworkInfo* data = reinterpret_cast<SystemStatusNetworkInfo*>(dataitem);
-    SystemStatusNetworkInfo s(data->mType,data->mTypeName,data->mSubTypeName,
-                              data->mAvailable,data->mConnected,data->mRoaming);
-    s.dump();
-    mConnected = data->mConnected;
-
-    if (!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;
 }
 
 /******************************************************************************
@@ -1445,17 +1319,6 @@ bool SystemStatus::setNetworkInfo(IDataItemCore* dataitem)
 
 @return     true when successfully done
 ******************************************************************************/
-static uint32_t cnt = 0;
-static uint32_t cnt_m1 = 0;
-static uint32_t cnt_p1 = 0;
-static uint32_t cnt_p2 = 0;
-static uint32_t cnt_p3 = 0;
-static uint32_t cnt_p4 = 0;
-static uint32_t cnt_p5 = 0;
-static uint32_t cnt_p6 = 0;
-static uint32_t cnt_p7 = 0;
-static uint32_t cnt_s1 = 0;
-
 bool SystemStatus::setNmeaString(const char *data, uint32_t len)
 {
     bool ret = false;
@@ -1471,59 +1334,46 @@ bool SystemStatus::setNmeaString(const char *data, uint32_t len)
     // parse the received nmea strings here
     if      (0 == strncmp(data, "$PQWM1", SystemStatusNmeaBase::NMEA_MINSIZE)) {
         SystemStatusPQWM1 s = SystemStatusPQWM1parser(buf, len).get();
-        ret  = setTimeAndCLock(s);
-        ret |= setXoState(s);
-        ret |= setRfAndParams(s);
-        ret |= setErrRecovery(s);
-        cnt_m1++;
+        ret |= setIteminReport(mCache.mTimeAndClock, SystemStatusTimeAndClock(s));
+        ret |= setIteminReport(mCache.mXoState, SystemStatusXoState(s));
+        ret |= setIteminReport(mCache.mRfAndParams, SystemStatusRfAndParams(s));
+        ret |= setIteminReport(mCache.mErrRecovery, SystemStatusErrRecovery(s));
     }
     else if (0 == strncmp(data, "$PQWP1", SystemStatusNmeaBase::NMEA_MINSIZE)) {
-        ret = setInjectedPosition(SystemStatusPQWP1parser(buf, len).get());
-        cnt_p1++;
+        ret = setIteminReport(mCache.mInjectedPosition,
+                SystemStatusInjectedPosition(SystemStatusPQWP1parser(buf, len).get()));
     }
     else if (0 == strncmp(data, "$PQWP2", SystemStatusNmeaBase::NMEA_MINSIZE)) {
-        ret = setBestPosition(SystemStatusPQWP2parser(buf, len).get());
-        cnt_p2++;
+        ret = setIteminReport(mCache.mBestPosition,
+                SystemStatusBestPosition(SystemStatusPQWP2parser(buf, len).get()));
     }
     else if (0 == strncmp(data, "$PQWP3", SystemStatusNmeaBase::NMEA_MINSIZE)) {
-        ret = setXtra(SystemStatusPQWP3parser(buf, len).get());
-        cnt_p3++;
+        ret = setIteminReport(mCache.mXtra,
+                SystemStatusXtra(SystemStatusPQWP3parser(buf, len).get()));
     }
     else if (0 == strncmp(data, "$PQWP4", SystemStatusNmeaBase::NMEA_MINSIZE)) {
-        ret = setEphemeris(SystemStatusPQWP4parser(buf, len).get());
-        cnt_p4++;
+        ret = setIteminReport(mCache.mEphemeris,
+                SystemStatusEphemeris(SystemStatusPQWP4parser(buf, len).get()));
     }
     else if (0 == strncmp(data, "$PQWP5", SystemStatusNmeaBase::NMEA_MINSIZE)) {
-        ret = setSvHealth(SystemStatusPQWP5parser(buf, len).get());
-        cnt_p5++;
+        ret = setIteminReport(mCache.mSvHealth,
+                SystemStatusSvHealth(SystemStatusPQWP5parser(buf, len).get()));
     }
     else if (0 == strncmp(data, "$PQWP6", SystemStatusNmeaBase::NMEA_MINSIZE)) {
-        ret = setPdr(SystemStatusPQWP6parser(buf, len).get());
-        cnt_p6++;
+        ret = setIteminReport(mCache.mPdr,
+                SystemStatusPdr(SystemStatusPQWP6parser(buf, len).get()));
     }
     else if (0 == strncmp(data, "$PQWP7", SystemStatusNmeaBase::NMEA_MINSIZE)) {
-        ret = setNavData(SystemStatusPQWP7parser(buf, len).get());
-        cnt_p7++;
+        ret = setIteminReport(mCache.mNavData,
+                SystemStatusNavData(SystemStatusPQWP7parser(buf, len).get()));
     }
     else if (0 == strncmp(data, "$PQWS1", SystemStatusNmeaBase::NMEA_MINSIZE)) {
-        ret = setPositionFailure(SystemStatusPQWS1parser(buf, len).get());
-        cnt_s1++;
+        ret = setIteminReport(mCache.mPositionFailure,
+                SystemStatusPositionFailure(SystemStatusPQWS1parser(buf, len).get()));
     }
     else {
         // do nothing
     }
-    cnt++;
-    LOC_LOGV("setNmeaString: cnt=%d M:%d 1:%d 2:%d 3:%d 4:%d 5:%d 6:%d 7:%d S:%d",
-             cnt,
-             cnt_m1,
-             cnt_p1,
-             cnt_p2,
-             cnt_p3,
-             cnt_p4,
-             cnt_p5,
-             cnt_p6,
-             cnt_p7,
-             cnt_s1);
 
     pthread_mutex_unlock(&mMutexSystemStatus);
     return ret;
@@ -1539,22 +1389,18 @@ bool SystemStatus::setNmeaString(const char *data, uint32_t len)
 bool SystemStatus::eventPosition(const UlpLocation& location,
                                  const GpsLocationExtended& locationEx)
 {
-    SystemStatusLocation s(location, locationEx);
-    if (!mCache.mLocation.empty() && mCache.mLocation.back().equals(s)) {
-        mCache.mLocation.back().mUtcReported = s.mUtcReported;
-    }
-    else {
-        mCache.mLocation.push_back(s);
-        if (mCache.mLocation.size() > maxLocation) {
-            mCache.mLocation.erase(mCache.mLocation.begin());
-        }
-    }
+    bool ret = false;
+    pthread_mutex_lock(&mMutexSystemStatus);
+
+    ret = setIteminReport(mCache.mLocation, SystemStatusLocation(location, locationEx));
     LOC_LOGV("eventPosition - lat=%f lon=%f alt=%f speed=%f",
-             s.mLocation.gpsLocation.latitude,
-             s.mLocation.gpsLocation.longitude,
-             s.mLocation.gpsLocation.altitude,
-             s.mLocation.gpsLocation.speed);
-    return true;
+             location.gpsLocation.latitude,
+             location.gpsLocation.longitude,
+             location.gpsLocation.altitude,
+             location.gpsLocation.speed);
+
+    pthread_mutex_unlock(&mMutexSystemStatus);
+    return ret;
 }
 
 /******************************************************************************
@@ -1562,19 +1408,109 @@ bool SystemStatus::eventPosition(const UlpLocation& location,
 
 @param[In]  DataItem
 
-@return     true when successfully done
+@return     true when info is updatated
 ******************************************************************************/
 bool SystemStatus::eventDataItemNotify(IDataItemCore* dataitem)
 {
+    bool ret = false;
     pthread_mutex_lock(&mMutexSystemStatus);
     switch(dataitem->getId())
     {
+        case AIRPLANEMODE_DATA_ITEM_ID:
+            ret = setItemBaseinReport<SystemStatusAirplaneMode>(mCache.mAirplaneMode,
+                    *(static_cast<AirplaneModeDataItemBase*>(dataitem)));
+            break;
+        case ENH_DATA_ITEM_ID:
+            ret = setItemBaseinReport<SystemStatusENH>(mCache.mENH,
+                    *(static_cast<ENHDataItemBase*>(dataitem)));
+            break;
+        case GPSSTATE_DATA_ITEM_ID:
+            ret = setItemBaseinReport<SystemStatusGpsState>(mCache.mGPSState,
+                    *(static_cast<GPSStateDataItemBase*>(dataitem)));
+            break;
+        case NLPSTATUS_DATA_ITEM_ID:
+            ret = setItemBaseinReport<SystemStatusNLPStatus>(mCache.mNLPStatus,
+                    *(static_cast<NLPStatusDataItemBase*>(dataitem)));
+            break;
+        case WIFIHARDWARESTATE_DATA_ITEM_ID:
+            ret = setItemBaseinReport<SystemStatusWifiHardwareState>(mCache.mWifiHardwareState,
+                    *(static_cast<WifiHardwareStateDataItemBase*>(dataitem)));
+            break;
         case NETWORKINFO_DATA_ITEM_ID:
-            setNetworkInfo(dataitem);
+            ret = setItemBaseinReport<SystemStatusNetworkInfo>(mCache.mNetworkInfo,
+                    *(static_cast<NetworkInfoDataItemBase*>(dataitem)));
+            break;
+        case RILSERVICEINFO_DATA_ITEM_ID:
+            ret = setItemBaseinReport<SystemStatusServiceInfo>(mCache.mRilServiceInfo,
+                    *(static_cast<RilServiceInfoDataItemBase*>(dataitem)));
+            break;
+        case RILCELLINFO_DATA_ITEM_ID:
+            ret = setItemBaseinReport<SystemStatusRilCellInfo>(mCache.mRilCellInfo,
+                    *(static_cast<RilCellInfoDataItemBase*>(dataitem)));
+            break;
+        case SERVICESTATUS_DATA_ITEM_ID:
+            ret = setItemBaseinReport<SystemStatusServiceStatus>(mCache.mServiceStatus,
+                    *(static_cast<ServiceStatusDataItemBase*>(dataitem)));
+            break;
+        case MODEL_DATA_ITEM_ID:
+            ret = setItemBaseinReport<SystemStatusModel>(mCache.mModel,
+                    *(static_cast<ModelDataItemBase*>(dataitem)));
+            break;
+        case MANUFACTURER_DATA_ITEM_ID:
+            ret = setItemBaseinReport<SystemStatusManufacturer>(mCache.mManufacturer,
+                    *(static_cast<ManufacturerDataItemBase*>(dataitem)));
+            break;
+        case ASSISTED_GPS_DATA_ITEM_ID:
+            ret = setItemBaseinReport<SystemStatusAssistedGps>(mCache.mAssistedGps,
+                    *(static_cast<AssistedGpsDataItemBase*>(dataitem)));
+            break;
+        case SCREEN_STATE_DATA_ITEM_ID:
+            ret = setItemBaseinReport<SystemStatusScreenState>(mCache.mScreenState,
+                    *(static_cast<ScreenStateDataItemBase*>(dataitem)));
+            break;
+        case POWER_CONNECTED_STATE_DATA_ITEM_ID:
+            ret = setItemBaseinReport<SystemStatusPowerConnectState>(mCache.mPowerConnectState,
+                    *(static_cast<PowerConnectStateDataItemBase*>(dataitem)));
+            break;
+        case TIMEZONE_CHANGE_DATA_ITEM_ID:
+            ret = setItemBaseinReport<SystemStatusTimeZoneChange>(mCache.mTimeZoneChange,
+                    *(static_cast<TimeZoneChangeDataItemBase*>(dataitem)));
+            break;
+        case TIME_CHANGE_DATA_ITEM_ID:
+            ret = setItemBaseinReport<SystemStatusTimeChange>(mCache.mTimeChange,
+                    *(static_cast<TimeChangeDataItemBase*>(dataitem)));
+            break;
+        case WIFI_SUPPLICANT_STATUS_DATA_ITEM_ID:
+            ret = setItemBaseinReport<SystemStatusWifiSupplicantStatus>(
+                    mCache.mWifiSupplicantStatus,
+                    *(static_cast<WifiSupplicantStatusDataItemBase*>(dataitem)));
+            break;
+        case SHUTDOWN_STATE_DATA_ITEM_ID:
+            ret = setItemBaseinReport<SystemStatusShutdownState>(mCache.mShutdownState,
+                    *(static_cast<ShutdownStateDataItemBase*>(dataitem)));
+            break;
+        case TAC_DATA_ITEM_ID:
+            ret = setItemBaseinReport<SystemStatusTac>(mCache.mTac,
+                    *(static_cast<TacDataItemBase*>(dataitem)));
+            break;
+        case MCCMNC_DATA_ITEM_ID:
+            ret = setItemBaseinReport<SystemStatusMccMnc>(mCache.mMccMnc,
+                    *(static_cast<MccmncDataItemBase*>(dataitem)));
+            break;
+        case BTLE_SCAN_DATA_ITEM_ID:
+            ret = setItemBaseinReport<SystemStatusBtDeviceScanDetail>(mCache.mBtDeviceScanDetail,
+                    *(static_cast<BtDeviceScanDetailsDataItemBase*>(dataitem)));
+            break;
+        case BT_SCAN_DATA_ITEM_ID:
+            ret = setItemBaseinReport<SystemStatusBtleDeviceScanDetail>(
+                    mCache.mBtLeDeviceScanDetail,
+                    *(static_cast<BtLeDeviceScanDetailsDataItemBase*>(dataitem)));
+            break;
+        default:
             break;
     }
     pthread_mutex_unlock(&mMutexSystemStatus);
-    return true;
+    return ret;
 }
 
 /******************************************************************************
@@ -1591,74 +1527,45 @@ bool SystemStatus::getReport(SystemStatusReports& report, bool isLatestOnly) con
 
     if (isLatestOnly) {
         // push back only the latest report and return it
-        report.mLocation.clear();
-        if (mCache.mLocation.size() >= 1) {
-            report.mLocation.push_back(mCache.mLocation.back());
-            report.mLocation.back().dump();
-        }
-
-        report.mTimeAndClock.clear();
-        if (mCache.mTimeAndClock.size() >= 1) {
-            report.mTimeAndClock.push_back(mCache.mTimeAndClock.back());
-            report.mTimeAndClock.back().dump();
-        }
-        report.mXoState.clear();
-        if (mCache.mXoState.size() >= 1) {
-            report.mXoState.push_back(mCache.mXoState.back());
-            report.mXoState.back().dump();
-        }
-        report.mRfAndParams.clear();
-        if (mCache.mRfAndParams.size() >= 1) {
-            report.mRfAndParams.push_back(mCache.mRfAndParams.back());
-            report.mRfAndParams.back().dump();
-        }
-        report.mErrRecovery.clear();
-        if (mCache.mErrRecovery.size() >= 1) {
-            report.mErrRecovery.push_back(mCache.mErrRecovery.back());
-            report.mErrRecovery.back().dump();
-        }
-
-        report.mInjectedPosition.clear();
-        if (mCache.mInjectedPosition.size() >= 1) {
-            report.mInjectedPosition.push_back(mCache.mInjectedPosition.back());
-            report.mInjectedPosition.back().dump();
-        }
-        report.mBestPosition.clear();
-        if (mCache.mBestPosition.size() >= 1) {
-            report.mBestPosition.push_back(mCache.mBestPosition.back());
-            report.mBestPosition.back().dump();
-        }
-        report.mXtra.clear();
-        if (mCache.mXtra.size() >= 1) {
-            report.mXtra.push_back(mCache.mXtra.back());
-            report.mXtra.back().dump();
-        }
-        report.mEphemeris.clear();
-        if (mCache.mEphemeris.size() >= 1) {
-            report.mEphemeris.push_back(mCache.mEphemeris.back());
-            report.mEphemeris.back().dump();
-        }
-        report.mSvHealth.clear();
-        if (mCache.mSvHealth.size() >= 1) {
-            report.mSvHealth.push_back(mCache.mSvHealth.back());
-            report.mSvHealth.back().dump();
-        }
-        report.mPdr.clear();
-        if (mCache.mPdr.size() >= 1) {
-            report.mPdr.push_back(mCache.mPdr.back());
-            report.mPdr.back().dump();
-        }
-        report.mNavData.clear();
-        if (mCache.mNavData.size() >= 1) {
-            report.mNavData.push_back(mCache.mNavData.back());
-            report.mNavData.back().dump();
-        }
-
-        report.mPositionFailure.clear();
-        if (mCache.mPositionFailure.size() >= 1) {
-            report.mPositionFailure.push_back(mCache.mPositionFailure.back());
-            report.mPositionFailure.back().dump();
-        }
+        getIteminReport(report.mLocation, mCache.mLocation);
+
+        getIteminReport(report.mTimeAndClock, mCache.mTimeAndClock);
+        getIteminReport(report.mXoState, mCache.mXoState);
+        getIteminReport(report.mRfAndParams, mCache.mRfAndParams);
+        getIteminReport(report.mErrRecovery, mCache.mErrRecovery);
+
+        getIteminReport(report.mInjectedPosition, mCache.mInjectedPosition);
+        getIteminReport(report.mBestPosition, mCache.mBestPosition);
+        getIteminReport(report.mXtra, mCache.mXtra);
+        getIteminReport(report.mEphemeris, mCache.mEphemeris);
+        getIteminReport(report.mSvHealth, mCache.mSvHealth);
+        getIteminReport(report.mPdr, mCache.mPdr);
+        getIteminReport(report.mNavData, mCache.mNavData);
+
+        getIteminReport(report.mPositionFailure, mCache.mPositionFailure);
+
+        getIteminReport(report.mAirplaneMode, mCache.mAirplaneMode);
+        getIteminReport(report.mENH, mCache.mENH);
+        getIteminReport(report.mGPSState, mCache.mGPSState);
+        getIteminReport(report.mNLPStatus, mCache.mNLPStatus);
+        getIteminReport(report.mWifiHardwareState, mCache.mWifiHardwareState);
+        getIteminReport(report.mNetworkInfo, mCache.mNetworkInfo);
+        getIteminReport(report.mRilServiceInfo, mCache.mRilServiceInfo);
+        getIteminReport(report.mRilCellInfo, mCache.mRilCellInfo);
+        getIteminReport(report.mServiceStatus, mCache.mServiceStatus);
+        getIteminReport(report.mModel, mCache.mModel);
+        getIteminReport(report.mManufacturer, mCache.mManufacturer);
+        getIteminReport(report.mAssistedGps, mCache.mAssistedGps);
+        getIteminReport(report.mScreenState, mCache.mScreenState);
+        getIteminReport(report.mPowerConnectState, mCache.mPowerConnectState);
+        getIteminReport(report.mTimeZoneChange, mCache.mTimeZoneChange);
+        getIteminReport(report.mTimeChange, mCache.mTimeChange);
+        getIteminReport(report.mWifiSupplicantStatus, mCache.mWifiSupplicantStatus);
+        getIteminReport(report.mShutdownState, mCache.mShutdownState);
+        getIteminReport(report.mTac, mCache.mTac);
+        getIteminReport(report.mMccMnc, mCache.mMccMnc);
+        getIteminReport(report.mBtDeviceScanDetail, mCache.mBtDeviceScanDetail);
+        getIteminReport(report.mBtLeDeviceScanDetail, mCache.mBtLeDeviceScanDetail);
     }
     else {
         // copy entire reports and return them
@@ -1678,6 +1585,30 @@ bool SystemStatus::getReport(SystemStatusReports& report, bool isLatestOnly) con
         report.mNavData.clear();
 
         report.mPositionFailure.clear();
+
+        report.mAirplaneMode.clear();
+        report.mENH.clear();
+        report.mGPSState.clear();
+        report.mNLPStatus.clear();
+        report.mWifiHardwareState.clear();
+        report.mNetworkInfo.clear();
+        report.mRilServiceInfo.clear();
+        report.mRilCellInfo.clear();
+        report.mServiceStatus.clear();
+        report.mModel.clear();
+        report.mManufacturer.clear();
+        report.mAssistedGps.clear();
+        report.mScreenState.clear();
+        report.mPowerConnectState.clear();
+        report.mTimeZoneChange.clear();
+        report.mTimeChange.clear();
+        report.mWifiSupplicantStatus.clear();
+        report.mShutdownState.clear();
+        report.mTac.clear();
+        report.mMccMnc.clear();
+        report.mBtDeviceScanDetail.clear();
+        report.mBtLeDeviceScanDetail.clear();
+
         report = mCache;
     }
 
@@ -1696,61 +1627,45 @@ bool SystemStatus::setDefaultReport(void)
 {
     pthread_mutex_lock(&mMutexSystemStatus);
 
-    mCache.mLocation.push_back(SystemStatusLocation());
-    if (mCache.mLocation.size() > maxLocation) {
-        mCache.mLocation.erase(mCache.mLocation.begin());
-    }
-
-    mCache.mTimeAndClock.push_back(SystemStatusTimeAndClock());
-    if (mCache.mTimeAndClock.size() > maxTimeAndClock) {
-        mCache.mTimeAndClock.erase(mCache.mTimeAndClock.begin());
-    }
-    mCache.mXoState.push_back(SystemStatusXoState());
-    if (mCache.mXoState.size() > maxXoState) {
-        mCache.mXoState.erase(mCache.mXoState.begin());
-    }
-    mCache.mRfAndParams.push_back(SystemStatusRfAndParams());
-    if (mCache.mRfAndParams.size() > maxRfAndParams) {
-        mCache.mRfAndParams.erase(mCache.mRfAndParams.begin());
-    }
-    mCache.mErrRecovery.push_back(SystemStatusErrRecovery());
-    if (mCache.mErrRecovery.size() > maxErrRecovery) {
-        mCache.mErrRecovery.erase(mCache.mErrRecovery.begin());
-    }
-
-    mCache.mInjectedPosition.push_back(SystemStatusInjectedPosition());
-    if (mCache.mInjectedPosition.size() > maxInjectedPosition) {
-        mCache.mInjectedPosition.erase(mCache.mInjectedPosition.begin());
-    }
-    mCache.mBestPosition.push_back(SystemStatusBestPosition());
-    if (mCache.mBestPosition.size() > maxBestPosition) {
-        mCache.mBestPosition.erase(mCache.mBestPosition.begin());
-    }
-    mCache.mXtra.push_back(SystemStatusXtra());
-    if (mCache.mXtra.size() > maxXtra) {
-        mCache.mXtra.erase(mCache.mXtra.begin());
-    }
-    mCache.mEphemeris.push_back(SystemStatusEphemeris());
-    if (mCache.mEphemeris.size() > maxEphemeris) {
-        mCache.mEphemeris.erase(mCache.mEphemeris.begin());
-    }
-    mCache.mSvHealth.push_back(SystemStatusSvHealth());
-    if (mCache.mSvHealth.size() > maxSvHealth) {
-        mCache.mSvHealth.erase(mCache.mSvHealth.begin());
-    }
-    mCache.mPdr.push_back(SystemStatusPdr());
-    if (mCache.mPdr.size() > maxPdr) {
-        mCache.mPdr.erase(mCache.mPdr.begin());
-    }
-    mCache.mNavData.push_back(SystemStatusNavData());
-    if (mCache.mNavData.size() > maxNavData) {
-        mCache.mNavData.erase(mCache.mNavData.begin());
-    }
-
-    mCache.mPositionFailure.push_back(SystemStatusPositionFailure());
-    if (mCache.mPositionFailure.size() > maxPositionFailure) {
-        mCache.mPositionFailure.erase(mCache.mPositionFailure.begin());
-    }
+    setDefaultIteminReport(mCache.mLocation, SystemStatusLocation());
+
+    setDefaultIteminReport(mCache.mTimeAndClock, SystemStatusTimeAndClock());
+    setDefaultIteminReport(mCache.mXoState, SystemStatusXoState());
+    setDefaultIteminReport(mCache.mRfAndParams, SystemStatusRfAndParams());
+    setDefaultIteminReport(mCache.mErrRecovery, SystemStatusErrRecovery());
+
+    setDefaultIteminReport(mCache.mInjectedPosition, SystemStatusInjectedPosition());
+    setDefaultIteminReport(mCache.mBestPosition, SystemStatusBestPosition());
+    setDefaultIteminReport(mCache.mXtra, SystemStatusXtra());
+    setDefaultIteminReport(mCache.mEphemeris, SystemStatusEphemeris());
+    setDefaultIteminReport(mCache.mSvHealth, SystemStatusSvHealth());
+    setDefaultIteminReport(mCache.mPdr, SystemStatusPdr());
+    setDefaultIteminReport(mCache.mNavData, SystemStatusNavData());
+
+    setDefaultIteminReport(mCache.mPositionFailure, SystemStatusPositionFailure());
+
+    setDefaultIteminReport(mCache.mAirplaneMode, SystemStatusAirplaneMode());
+    setDefaultIteminReport(mCache.mENH, SystemStatusENH());
+    setDefaultIteminReport(mCache.mGPSState, SystemStatusGpsState());
+    setDefaultIteminReport(mCache.mNLPStatus, SystemStatusNLPStatus());
+    setDefaultIteminReport(mCache.mWifiHardwareState, SystemStatusWifiHardwareState());
+    setDefaultIteminReport(mCache.mNetworkInfo, SystemStatusNetworkInfo());
+    setDefaultIteminReport(mCache.mRilServiceInfo, SystemStatusServiceInfo());
+    setDefaultIteminReport(mCache.mRilCellInfo, SystemStatusRilCellInfo());
+    setDefaultIteminReport(mCache.mServiceStatus, SystemStatusServiceStatus());
+    setDefaultIteminReport(mCache.mModel, SystemStatusModel());
+    setDefaultIteminReport(mCache.mManufacturer, SystemStatusManufacturer());
+    setDefaultIteminReport(mCache.mAssistedGps, SystemStatusAssistedGps());
+    setDefaultIteminReport(mCache.mScreenState, SystemStatusScreenState());
+    setDefaultIteminReport(mCache.mPowerConnectState, SystemStatusPowerConnectState());
+    setDefaultIteminReport(mCache.mTimeZoneChange, SystemStatusTimeZoneChange());
+    setDefaultIteminReport(mCache.mTimeChange, SystemStatusTimeChange());
+    setDefaultIteminReport(mCache.mWifiSupplicantStatus, SystemStatusWifiSupplicantStatus());
+    setDefaultIteminReport(mCache.mShutdownState, SystemStatusShutdownState());
+    setDefaultIteminReport(mCache.mTac, SystemStatusTac());
+    setDefaultIteminReport(mCache.mMccMnc, SystemStatusMccMnc());
+    setDefaultIteminReport(mCache.mBtDeviceScanDetail, SystemStatusBtDeviceScanDetail());
+    setDefaultIteminReport(mCache.mBtLeDeviceScanDetail, SystemStatusBtleDeviceScanDetail());
 
     pthread_mutex_unlock(&mMutexSystemStatus);
     return true;
@@ -1770,15 +1685,8 @@ bool SystemStatus::eventConnectionStatus(bool connected, uint8_t type)
 
         // send networkinof dataitem to systemstatus observer clients
         SystemStatusNetworkInfo s(type, "", "", false, connected, false);
-        IDataItemCore *networkinfo =
-                DataItemsFactoryProxy::createNewDataItem(NETWORKINFO_DATA_ITEM_ID);
-        if (nullptr == networkinfo) {
-            LOC_LOGE("Unable to create dataitemd");
-            return false;
-        }
-        networkinfo->copy(&s);
         list<IDataItemCore*> dl(0);
-        dl.push_back(networkinfo);
+        dl.push_back(&s);
         mSysStatusObsvr.notify(dl);
     }
     return true;
diff --git a/gps/core/SystemStatus.h b/gps/core/SystemStatus.h
index 5dc2d9f..1bcef10 100644
--- a/gps/core/SystemStatus.h
+++ b/gps/core/SystemStatus.h
@@ -36,6 +36,7 @@
 #include <MsgTask.h>
 #include <IDataItemCore.h>
 #include <IOsObserver.h>
+#include <DataItemConcreteTypesBase.h>
 #include <SystemStatusOsObserver.h>
 
 #include <gps_extended_c.h>
@@ -66,6 +67,7 @@ class SystemStatusItemBase
 public:
     timespec mUtcTime;     // UTC timestamp when this info was last updated
     timespec mUtcReported; // UTC timestamp when this info was reported
+    static const uint32_t maxItem = 5;
 
     SystemStatusItemBase() {
         timeval tv;
@@ -91,7 +93,7 @@ public:
         mValid(true),
         mLocation(location),
         mLocationEx(locationEx) { }
-    bool equals(SystemStatusLocation& peer);
+    bool equals(const SystemStatusLocation& peer);
     void dump(void);
 };
 
@@ -119,7 +121,7 @@ public:
         mLeapSeconds(0),
         mLeapSecUnc(0) {}
     inline SystemStatusTimeAndClock(const SystemStatusPQWM1& nmea);
-    bool equals(SystemStatusTimeAndClock& peer);
+    bool equals(const SystemStatusTimeAndClock& peer);
     void dump(void);
 };
 
@@ -130,7 +132,7 @@ public:
     inline SystemStatusXoState() :
         mXoState(0) {}
     inline SystemStatusXoState(const SystemStatusPQWM1& nmea);
-    bool equals(SystemStatusXoState& peer);
+    bool equals(const SystemStatusXoState& peer);
     void dump(void);
 };
 
@@ -165,7 +167,7 @@ public:
         mAgcBds(0),
         mAgcGal(0) {}
     inline SystemStatusRfAndParams(const SystemStatusPQWM1& nmea);
-    bool equals(SystemStatusRfAndParams& peer);
+    bool equals(const SystemStatusRfAndParams& peer);
     void dump(void);
 };
 
@@ -176,7 +178,7 @@ public:
     inline SystemStatusErrRecovery() :
         mRecErrorRecovery(0) {};
     inline SystemStatusErrRecovery(const SystemStatusPQWM1& nmea);
-    bool equals(SystemStatusErrRecovery& peer);
+    bool equals(const SystemStatusErrRecovery& peer);
     void dump(void);
 };
 
@@ -200,7 +202,7 @@ public:
         mEpiAltUnc(0),
         mEpiSrc(0) {}
     inline SystemStatusInjectedPosition(const SystemStatusPQWP1& nmea);
-    bool equals(SystemStatusInjectedPosition& peer);
+    bool equals(const SystemStatusInjectedPosition& peer);
     void dump(void);
 };
 
@@ -222,7 +224,7 @@ public:
         mBestHepe(0),
         mBestAltUnc(0) {}
     inline SystemStatusBestPosition(const SystemStatusPQWP2& nmea);
-    bool equals(SystemStatusBestPosition& peer);
+    bool equals(const SystemStatusBestPosition& peer);
     void dump(void);
 };
 
@@ -254,7 +256,7 @@ public:
         mGalXtraValid(0ULL),
         mQzssXtraValid(0) {}
     inline SystemStatusXtra(const SystemStatusPQWP3& nmea);
-    bool equals(SystemStatusXtra& peer);
+    bool equals(const SystemStatusXtra& peer);
     void dump(void);
 };
 
@@ -274,7 +276,7 @@ public:
         mGalEpheValid(0ULL),
         mQzssEpheValid(0) {}
     inline SystemStatusEphemeris(const SystemStatusPQWP4& nmea);
-    bool equals(SystemStatusEphemeris& peer);
+    bool equals(const SystemStatusEphemeris& peer);
     void dump(void);
 };
 
@@ -314,7 +316,7 @@ public:
         mGalBadMask(0ULL),
         mQzssBadMask(0) {}
     inline SystemStatusSvHealth(const SystemStatusPQWP5& nmea);
-    bool equals(SystemStatusSvHealth& peer);
+    bool equals(const SystemStatusSvHealth& peer);
     void dump(void);
 };
 
@@ -326,7 +328,7 @@ public:
     inline SystemStatusPdr() :
         mFixInfoMask(0) {}
     inline SystemStatusPdr(const SystemStatusPQWP6& nmea);
-    bool equals(SystemStatusPdr& peer);
+    bool equals(const SystemStatusPdr& peer);
     void dump(void);
 };
 
@@ -350,7 +352,7 @@ public:
         }
     }
     inline SystemStatusNavData(const SystemStatusPQWP7& nmea);
-    bool equals(SystemStatusNavData& peer);
+    bool equals(const SystemStatusNavData& peer);
     void dump(void);
 };
 
@@ -364,168 +366,339 @@ public:
         mFixInfoMask(0),
         mHepeLimit(0) {}
     inline SystemStatusPositionFailure(const SystemStatusPQWS1& nmea);
-    bool equals(SystemStatusPositionFailure& peer);
+    bool equals(const SystemStatusPositionFailure& peer);
     void dump(void);
 };
 
 /******************************************************************************
  SystemStatus report data structure - from DataItem observer
 ******************************************************************************/
-class SystemStatusGpsState : public SystemStatusItemBase, public IDataItemCore
+class SystemStatusAirplaneMode : public SystemStatusItemBase,
+        public AirplaneModeDataItemBase
 {
 public:
-    inline SystemStatusGpsState() :
-            mEnabled(false) {}
-    inline SystemStatusGpsState(bool enabled) :
-            mEnabled(enabled) {}
+    inline SystemStatusAirplaneMode(bool mode=false) :
+            AirplaneModeDataItemBase(mode) {}
+    inline SystemStatusAirplaneMode(const AirplaneModeDataItemBase& itemBase) :
+            AirplaneModeDataItemBase(itemBase) {}
+    inline bool equals(const SystemStatusAirplaneMode& peer) {
+        return (mMode == peer.mMode);
+    }
+};
 
-    bool mEnabled;
+class SystemStatusENH : public SystemStatusItemBase,
+        public ENHDataItemBase
+{
+public:
+    inline SystemStatusENH(bool enabled=false) :
+            ENHDataItemBase(enabled) {}
+    inline SystemStatusENH(const ENHDataItemBase& itemBase) :
+            ENHDataItemBase(itemBase) {}
+    inline bool equals(const SystemStatusENH& peer) {
+        return (mEnabled == peer.mEnabled);
+    }
+};
 
-    inline bool equals(SystemStatusGpsState& peer) {
+class SystemStatusGpsState : public SystemStatusItemBase,
+        public GPSStateDataItemBase
+{
+public:
+    inline SystemStatusGpsState(bool enabled=false) :
+            GPSStateDataItemBase(enabled) {}
+    inline SystemStatusGpsState(const GPSStateDataItemBase& itemBase) :
+            GPSStateDataItemBase(itemBase) {}
+    inline bool equals(const SystemStatusGpsState& peer) {
         return (mEnabled == peer.mEnabled);
     }
-    inline void dump(void) {
+    inline void dump(void) override {
         LOC_LOGD("GpsState: state=%u", mEnabled);
     }
-    inline DataItemId getId() {
-        return GPSSTATE_DATA_ITEM_ID;
-    }
-    inline void stringify(string& valueStr) {
-        valueStr.clear();
-        valueStr += "GpsState: enabled=";
-        valueStr += to_string(mEnabled);
+};
+
+class SystemStatusNLPStatus : public SystemStatusItemBase,
+        public NLPStatusDataItemBase
+{
+public:
+    inline SystemStatusNLPStatus(bool enabled=false) :
+            NLPStatusDataItemBase(enabled) {}
+    inline SystemStatusNLPStatus(const NLPStatusDataItemBase& itemBase) :
+            NLPStatusDataItemBase(itemBase) {}
+    inline bool equals(const SystemStatusNLPStatus& peer) {
+        return (mEnabled == peer.mEnabled);
     }
-    inline int32_t copy(IDataItemCore* src, bool* dataItemCopied = nullptr) {
-        SystemStatusGpsState* gpsstate = static_cast<SystemStatusGpsState*>(src);
-        mEnabled = gpsstate->mEnabled;
-        if (dataItemCopied) {
-            *dataItemCopied = true;
-        }
-        return 1;
+};
+
+class SystemStatusWifiHardwareState : public SystemStatusItemBase,
+        public WifiHardwareStateDataItemBase
+{
+public:
+    inline SystemStatusWifiHardwareState(bool enabled=false) :
+            WifiHardwareStateDataItemBase(enabled) {}
+    inline SystemStatusWifiHardwareState(const WifiHardwareStateDataItemBase& itemBase) :
+            WifiHardwareStateDataItemBase(itemBase) {}
+    inline bool equals(const SystemStatusWifiHardwareState& peer) {
+        return (mEnabled == peer.mEnabled);
     }
 };
 
-class SystemStatusNetworkInfo : public SystemStatusItemBase, public IDataItemCore
+class SystemStatusNetworkInfo : public SystemStatusItemBase,
+        public NetworkInfoDataItemBase
 {
 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;
+            int32_t type=0,
+            std::string typeName="",
+            string subTypeName="",
+            bool available=false,
+            bool connected=false,
+            bool roaming=false) :
+            NetworkInfoDataItemBase(
+                    type,
+                    typeName,
+                    subTypeName,
+                    available,
+                    connected,
+                    roaming) {}
+    inline SystemStatusNetworkInfo(const NetworkInfoDataItemBase& itemBase) :
+            NetworkInfoDataItemBase(itemBase) {
+        mType = itemBase.getType();
+    }
+    inline bool equals(const SystemStatusNetworkInfo& peer) {
+        if ((mType == peer.mType) &&
+            (mTypeName == peer.mTypeName) &&
+            (mSubTypeName == peer.mSubTypeName) &&
+            (mAvailable == peer.mAvailable) &&
+            (mConnected == peer.mConnected) &&
+            (mRoaming == peer.mRoaming)) {
+            return true;
         }
-        return true;
+        return false;
     }
-    inline void dump(void) {
+    inline void dump(void) override {
         LOC_LOGD("NetworkInfo: type=%u connected=%u", mType, mConnected);
     }
-    inline DataItemId getId() {
-        return NETWORKINFO_DATA_ITEM_ID;
+};
+
+class SystemStatusServiceInfo : public SystemStatusItemBase,
+        public RilServiceInfoDataItemBase
+{
+public:
+    inline SystemStatusServiceInfo() :
+            RilServiceInfoDataItemBase() {}
+    inline SystemStatusServiceInfo(const RilServiceInfoDataItemBase& itemBase) :
+            RilServiceInfoDataItemBase(itemBase) {}
+    inline bool equals(const SystemStatusServiceInfo& /*peer*/) {
+        return true;
+    }
+};
+
+class SystemStatusRilCellInfo : public SystemStatusItemBase,
+        public RilCellInfoDataItemBase
+{
+public:
+    inline SystemStatusRilCellInfo() :
+            RilCellInfoDataItemBase() {}
+    inline SystemStatusRilCellInfo(const RilCellInfoDataItemBase& itemBase) :
+            RilCellInfoDataItemBase(itemBase) {}
+    inline bool equals(const SystemStatusRilCellInfo& /*peer*/) {
+        return true;
+    }
+};
+
+class SystemStatusServiceStatus : public SystemStatusItemBase,
+        public ServiceStatusDataItemBase
+{
+public:
+    inline SystemStatusServiceStatus(int32_t mServiceState=0) :
+            ServiceStatusDataItemBase(mServiceState) {}
+    inline SystemStatusServiceStatus(const ServiceStatusDataItemBase& itemBase) :
+            ServiceStatusDataItemBase(itemBase) {}
+    inline bool equals(const SystemStatusServiceStatus& peer) {
+        return (mServiceState == peer.mServiceState);
     }
-    inline void stringify(string& /*valueStr*/) { }
-    inline int32_t copy(IDataItemCore* src, bool* dataItemCopied = nullptr) {
-        SystemStatusNetworkInfo* networkinfo = static_cast<SystemStatusNetworkInfo*>(src);
-        mType = networkinfo->mType;
-        mTypeName = networkinfo->mTypeName;
-        mSubTypeName = networkinfo->mSubTypeName;
-        mAvailable = networkinfo->mAvailable;
-        mConnected = networkinfo->mConnected;
-        mRoaming = networkinfo->mRoaming;
-        if (dataItemCopied) {
-            *dataItemCopied = true;
+};
+
+class SystemStatusModel : public SystemStatusItemBase,
+        public ModelDataItemBase
+{
+public:
+    inline SystemStatusModel(string name="") :
+            ModelDataItemBase(name) {}
+    inline SystemStatusModel(const ModelDataItemBase& itemBase) :
+            ModelDataItemBase(itemBase) {}
+    inline bool equals(const SystemStatusModel& peer) {
+        return (mModel == peer.mModel);
         }
-        return 1;
+};
+
+class SystemStatusManufacturer : public SystemStatusItemBase,
+        public ManufacturerDataItemBase
+{
+public:
+    inline SystemStatusManufacturer(string name="") :
+            ManufacturerDataItemBase(name) {}
+    inline SystemStatusManufacturer(const ManufacturerDataItemBase& itemBase) :
+            ManufacturerDataItemBase(itemBase) {}
+    inline bool equals(const SystemStatusManufacturer& peer) {
+        return (mManufacturer == peer.mManufacturer);
     }
 };
 
-class SystemStatusTac : public SystemStatusItemBase, public IDataItemCore
+class SystemStatusAssistedGps : public SystemStatusItemBase,
+        public AssistedGpsDataItemBase
 {
 public:
-    inline SystemStatusTac() :
-            mValue("") {}
-    inline SystemStatusTac(std::string value) :
-            mValue(value) {}
+    inline SystemStatusAssistedGps(bool enabled=false) :
+            AssistedGpsDataItemBase(enabled) {}
+    inline SystemStatusAssistedGps(const AssistedGpsDataItemBase& itemBase) :
+            AssistedGpsDataItemBase(itemBase) {}
+    inline bool equals(const SystemStatusAssistedGps& peer) {
+        return (mEnabled == peer.mEnabled);
+    }
+};
 
-    std::string mValue;
+class SystemStatusScreenState : public SystemStatusItemBase,
+        public ScreenStateDataItemBase
+{
+public:
+    inline SystemStatusScreenState(bool state=false) :
+            ScreenStateDataItemBase(state) {}
+    inline SystemStatusScreenState(const ScreenStateDataItemBase& itemBase) :
+            ScreenStateDataItemBase(itemBase) {}
+    inline bool equals(const SystemStatusScreenState& peer) {
+        return (mState == peer.mState);
+    }
+};
 
-    inline bool equals(SystemStatusTac& peer) {
-        return (mValue == peer.mValue);
+class SystemStatusPowerConnectState : public SystemStatusItemBase,
+        public PowerConnectStateDataItemBase
+{
+public:
+    inline SystemStatusPowerConnectState(bool state=false) :
+            PowerConnectStateDataItemBase(state) {}
+    inline SystemStatusPowerConnectState(const PowerConnectStateDataItemBase& itemBase) :
+            PowerConnectStateDataItemBase(itemBase) {}
+    inline bool equals(const SystemStatusPowerConnectState& peer) {
+        return (mState == peer.mState);
     }
-    inline void dump(void) {
-        LOC_LOGD("Tac: value=%s", mValue.c_str());
+};
+
+class SystemStatusTimeZoneChange : public SystemStatusItemBase,
+        public TimeZoneChangeDataItemBase
+{
+public:
+    inline SystemStatusTimeZoneChange(
+            int64_t currTimeMillis=0ULL, int32_t rawOffset=0, int32_t dstOffset=0) :
+            TimeZoneChangeDataItemBase(currTimeMillis, rawOffset, dstOffset) {}
+    inline SystemStatusTimeZoneChange(const TimeZoneChangeDataItemBase& itemBase) :
+            TimeZoneChangeDataItemBase(itemBase) {}
+    inline bool equals(const SystemStatusTimeZoneChange& peer) {
+        return ((mCurrTimeMillis == peer.mCurrTimeMillis) &&
+                (mRawOffsetTZ == peer.mRawOffsetTZ) &&
+                (mDstOffsetTZ == peer.mDstOffsetTZ));
     }
-    inline DataItemId getId() {
-        return TAC_DATA_ITEM_ID;
+};
+
+class SystemStatusTimeChange : public SystemStatusItemBase,
+        public TimeChangeDataItemBase
+{
+public:
+    inline SystemStatusTimeChange(
+            int64_t currTimeMillis=0ULL, int32_t rawOffset=0, int32_t dstOffset=0) :
+            TimeChangeDataItemBase(currTimeMillis, rawOffset, dstOffset) {}
+    inline SystemStatusTimeChange(const TimeChangeDataItemBase& itemBase) :
+            TimeChangeDataItemBase(itemBase) {}
+    inline bool equals(const SystemStatusTimeChange& peer) {
+        return ((mCurrTimeMillis == peer.mCurrTimeMillis) &&
+                (mRawOffsetTZ == peer.mRawOffsetTZ) &&
+                (mDstOffsetTZ == peer.mDstOffsetTZ));
     }
-    inline void stringify(string& /*valueStr*/) { }
-    inline int32_t copy(IDataItemCore* src, bool* dataItemCopied = nullptr) {
-        SystemStatusTac* tac = static_cast<SystemStatusTac*>(src);
-        mValue = tac->mValue;
-        if (dataItemCopied) {
-            *dataItemCopied = true;
+};
+
+class SystemStatusWifiSupplicantStatus : public SystemStatusItemBase,
+        public WifiSupplicantStatusDataItemBase
+{
+public:
+    inline SystemStatusWifiSupplicantStatus() :
+            WifiSupplicantStatusDataItemBase() {}
+    inline SystemStatusWifiSupplicantStatus(const WifiSupplicantStatusDataItemBase& itemBase) :
+            WifiSupplicantStatusDataItemBase(itemBase) {}
+    inline bool equals(const SystemStatusWifiSupplicantStatus& peer) {
+        return ((mState == peer.mState) &&
+                (mApMacAddressValid == peer.mApMacAddressValid) &&
+                (mWifiApSsidValid == peer.mWifiApSsidValid) &&
+                (mWifiApSsid == peer.mWifiApSsid));
         }
-        return 1;
-    }
 };
 
-class SystemStatusMccMnc : public SystemStatusItemBase, public IDataItemCore
+class SystemStatusShutdownState : public SystemStatusItemBase,
+        public ShutdownStateDataItemBase
 {
 public:
-    inline SystemStatusMccMnc() :
-            mValue("") {}
-    inline SystemStatusMccMnc(std::string value) :
-            mValue(value) {}
+    inline SystemStatusShutdownState(bool state=false) :
+            ShutdownStateDataItemBase(state) {}
+    inline SystemStatusShutdownState(const ShutdownStateDataItemBase& itemBase) :
+            ShutdownStateDataItemBase(itemBase) {}
+    inline bool equals(const SystemStatusShutdownState& peer) {
+        return (mState == peer.mState);
+    }
+};
 
-    std::string mValue;
+class SystemStatusTac : public SystemStatusItemBase,
+        public TacDataItemBase
+{
+public:
+    inline SystemStatusTac(std::string value="") :
+            TacDataItemBase(value) {}
+    inline SystemStatusTac(const TacDataItemBase& itemBase) :
+            TacDataItemBase(itemBase) {}
+    inline bool equals(const SystemStatusTac& peer) {
+        return (mValue == peer.mValue);
+    }
+    inline void dump(void) {
+        LOC_LOGD("Tac: value=%s", mValue.c_str());
+    }
+};
 
-    inline bool equals(SystemStatusMccMnc& peer) {
+class SystemStatusMccMnc : public SystemStatusItemBase,
+        public MccmncDataItemBase
+{
+public:
+    inline SystemStatusMccMnc(std::string value="") :
+            MccmncDataItemBase(value) {}
+    inline SystemStatusMccMnc(const MccmncDataItemBase& itemBase) :
+            MccmncDataItemBase(itemBase) {}
+    inline bool equals(const SystemStatusMccMnc& peer) {
         return (mValue == peer.mValue);
     }
     inline void dump(void) {
         LOC_LOGD("TacMccMnc value=%s", mValue.c_str());
     }
-    inline DataItemId getId() {
-        return MCCMNC_DATA_ITEM_ID;
+};
+
+class SystemStatusBtDeviceScanDetail : public SystemStatusItemBase,
+        public BtDeviceScanDetailsDataItemBase
+{
+public:
+    inline SystemStatusBtDeviceScanDetail() :
+            BtDeviceScanDetailsDataItemBase() {}
+    inline SystemStatusBtDeviceScanDetail(const BtDeviceScanDetailsDataItemBase& itemBase) :
+            BtDeviceScanDetailsDataItemBase(itemBase) {}
+    inline bool equals(const SystemStatusBtDeviceScanDetail& /*peer*/) {
+        return true;
     }
-    inline void stringify(string& /*valueStr*/) { }
-    inline int32_t copy(IDataItemCore* src, bool* dataItemCopied = nullptr) {
-        SystemStatusMccMnc* mccmnc = static_cast<SystemStatusMccMnc*>(src);
-        mValue = mccmnc->mValue;
-        if (dataItemCopied) {
-            *dataItemCopied = true;
-        }
-        return 1;
+};
+
+class SystemStatusBtleDeviceScanDetail : public SystemStatusItemBase,
+        public BtLeDeviceScanDetailsDataItemBase
+{
+public:
+    inline SystemStatusBtleDeviceScanDetail() :
+            BtLeDeviceScanDetailsDataItemBase() {}
+    inline SystemStatusBtleDeviceScanDetail(const BtLeDeviceScanDetailsDataItemBase& itemBase) :
+            BtLeDeviceScanDetailsDataItemBase(itemBase) {}
+    inline bool equals(const SystemStatusBtleDeviceScanDetail& /*peer*/) {
+        return true;
     }
 };
 
@@ -557,10 +730,28 @@ public:
     std::vector<SystemStatusPositionFailure>  mPositionFailure;
 
     // from dataitems observer
-    std::vector<SystemStatusGpsState>         mGpsState;
+    std::vector<SystemStatusAirplaneMode>     mAirplaneMode;
+    std::vector<SystemStatusENH>              mENH;
+    std::vector<SystemStatusGpsState>         mGPSState;
+    std::vector<SystemStatusNLPStatus>        mNLPStatus;
+    std::vector<SystemStatusWifiHardwareState> mWifiHardwareState;
     std::vector<SystemStatusNetworkInfo>      mNetworkInfo;
+    std::vector<SystemStatusServiceInfo>      mRilServiceInfo;
+    std::vector<SystemStatusRilCellInfo>      mRilCellInfo;
+    std::vector<SystemStatusServiceStatus>    mServiceStatus;
+    std::vector<SystemStatusModel>            mModel;
+    std::vector<SystemStatusManufacturer>     mManufacturer;
+    std::vector<SystemStatusAssistedGps>      mAssistedGps;
+    std::vector<SystemStatusScreenState>      mScreenState;
+    std::vector<SystemStatusPowerConnectState> mPowerConnectState;
+    std::vector<SystemStatusTimeZoneChange>   mTimeZoneChange;
+    std::vector<SystemStatusTimeChange>       mTimeChange;
+    std::vector<SystemStatusWifiSupplicantStatus> mWifiSupplicantStatus;
+    std::vector<SystemStatusShutdownState>    mShutdownState;
     std::vector<SystemStatusTac>              mTac;
     std::vector<SystemStatusMccMnc>           mMccMnc;
+    std::vector<SystemStatusBtDeviceScanDetail> mBtDeviceScanDetail;
+    std::vector<SystemStatusBtleDeviceScanDetail> mBtLeDeviceScanDetail;
 };
 
 /******************************************************************************
@@ -578,50 +769,21 @@ private:
 
     // Data members
     static pthread_mutex_t                    mMutexSystemStatus;
-
-    static const uint32_t                     maxLocation = 5;
-
-    static const uint32_t                     maxTimeAndClock = 5;
-    static const uint32_t                     maxXoState = 5;
-    static const uint32_t                     maxRfAndParams = 5;
-    static const uint32_t                     maxErrRecovery = 5;
-
-    static const uint32_t                     maxInjectedPosition = 5;
-    static const uint32_t                     maxBestPosition = 5;
-    static const uint32_t                     maxXtra = 5;
-    static const uint32_t                     maxEphemeris = 5;
-    static const uint32_t                     maxSvHealth = 5;
-    static const uint32_t                     maxPdr = 5;
-    static const uint32_t                     maxNavData = 5;
-
-    static const uint32_t                     maxPositionFailure = 5;
-
-    static const uint32_t                     maxGpsState = 5;
-    static const uint32_t                     maxNetworkInfo = 5;
-    static const uint32_t                     maxTac = 5;
-    static const uint32_t                     maxMccMnc = 5;
-
     SystemStatusReports mCache;
     bool mConnected;
 
-    bool setLocation(const UlpLocation& location);
-
-    bool setTimeAndCLock(const SystemStatusPQWM1& nmea);
-    bool setXoState(const SystemStatusPQWM1& nmea);
-    bool setRfAndParams(const SystemStatusPQWM1& nmea);
-    bool setErrRecovery(const SystemStatusPQWM1& nmea);
+    template <typename TYPE_SYSTEMSTATUS_ITEM, typename TYPE_REPORT, typename TYPE_ITEMBASE>
+    bool setItemBaseinReport(TYPE_REPORT& report, const TYPE_ITEMBASE& s);
 
-    bool setInjectedPosition(const SystemStatusPQWP1& nmea);
-    bool setBestPosition(const SystemStatusPQWP2& nmea);
-    bool setXtra(const SystemStatusPQWP3& nmea);
-    bool setEphemeris(const SystemStatusPQWP4& nmea);
-    bool setSvHealth(const SystemStatusPQWP5& nmea);
-    bool setPdr(const SystemStatusPQWP6& nmea);
-    bool setNavData(const SystemStatusPQWP7& nmea);
+    template <typename TYPE_REPORT, typename TYPE_ITEM>
+    bool setIteminReport(TYPE_REPORT& report, const TYPE_ITEM& s);
 
-    bool setPositionFailure(const SystemStatusPQWS1& nmea);
+    // set default dataitem derived item in report cache
+    template <typename TYPE_REPORT, typename TYPE_ITEM>
+    void setDefaultIteminReport(TYPE_REPORT& report, const TYPE_ITEM& s);
 
-    bool setNetworkInfo(IDataItemCore* dataitem);
+    template <typename TYPE_REPORT, typename TYPE_ITEM>
+    void getIteminReport(TYPE_REPORT& reportout, const TYPE_ITEM& c) const;
 
 public:
     // Static methods
diff --git a/gps/core/SystemStatusOsObserver.cpp b/gps/core/SystemStatusOsObserver.cpp
index 319f1d7..541b5fd 100644
--- a/gps/core/SystemStatusOsObserver.cpp
+++ b/gps/core/SystemStatusOsObserver.cpp
@@ -39,7 +39,9 @@
 
 namespace loc_core
 {
-SystemStatusOsObserver::SystemStatusOsObserver(const MsgTask* msgTask) :
+SystemStatusOsObserver::SystemStatusOsObserver(
+    SystemStatus* systemstatus, const MsgTask* msgTask) :
+    mSystemStatus(systemstatus),
     mAddress("SystemStatusOsObserver"),
     mClientIndex(IndexFactory<IDataItemObserver*, DataItemId> :: createClientIndex()),
     mDataItemIndex(IndexFactory<IDataItemObserver*, DataItemId> :: createDataItemIndex())
@@ -366,11 +368,11 @@ void SystemStatusOsObserver::notify(const list<IDataItemCore*>& dlist)
 
         // Copy contents into the newly created data item
         di->copy(each);
-        dataItemList.push_back(di);
+
         // Request systemstatus to record this dataitem in its cache
-        SystemStatus* systemstatus = SystemStatus::getInstance(mContext.mMsgTask);
-        if(nullptr != systemstatus) {
-            systemstatus->eventDataItemNotify(di);
+        if (mSystemStatus->eventDataItemNotify(di)) {
+            // add this dataitem if updated from last one
+            dataItemList.push_back(di);
         }
     }
 
diff --git a/gps/core/SystemStatusOsObserver.h b/gps/core/SystemStatusOsObserver.h
index 985e5c9..fa114ee 100644
--- a/gps/core/SystemStatusOsObserver.h
+++ b/gps/core/SystemStatusOsObserver.h
@@ -70,12 +70,13 @@ typedef map<IDataItemObserver*, list<DataItemId>> ObserverReqCache;
 // subscribe with OSObserver using IDataItemSubscription interface.
 // Such clients would need to implement IDataItemObserver interface
 // to receive data when it becomes available.
+class SystemStatus;
 class SystemStatusOsObserver : public IOsObserver {
 
 public:
     // ctor
-    SystemStatusOsObserver(const MsgTask* msgTask);
-
+    SystemStatusOsObserver(
+            SystemStatus* systemstatus, const MsgTask* msgTask);
     // dtor
     ~SystemStatusOsObserver();
 
@@ -105,6 +106,7 @@ public:
     virtual void turnOff(DataItemId dit);
 
 private:
+    SystemStatus*                                    mSystemStatus;
     SystemContext                                    mContext;
     const string                                     mAddress;
     IClientIndex<IDataItemObserver*, DataItemId>*    mClientIndex;
diff --git a/gps/core/data-items/DataItemConcreteTypesBase.h b/gps/core/data-items/DataItemConcreteTypesBase.h
new file mode 100644
index 0000000..df3bf9a
--- /dev/null
+++ b/gps/core/data-items/DataItemConcreteTypesBase.h
@@ -0,0 +1,461 @@
+/* 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 <string>
+#include <cstring>
+#include <DataItemId.h>
+#include <IDataItemCore.h>
+
+#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;}
+    enum NetworkType {
+        TYPE_UNKNOWN,
+        TYPE_MOBILE,
+        TYPE_WIFI,
+        TYPE_ETHERNET,
+        TYPE_BLUETOOTH,
+        TYPE_MMS,
+        TYPE_SUPL,
+        TYPE_DUN,
+        TYPE_HIPRI,
+        TYPE_WIMAX
+    };
+    inline virtual NetworkType getType(void) const {
+        return (NetworkType)mType;
+    }
+// Data members
+    int32_t mType;
+    string mTypeName;
+    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__