msm8996: gps: Squashed update to LA.UM.6.5.r1-05300-8x96.0

Change-Id: I76b39dd5329a050d44f126c684edb44b0184f0fc
Signed-off-by: Davide Garberi <dade.garberi@gmail.com>

7 files changed, 378 insertions, 255 deletions

diff --git a/gps/gnss/Agps.cpp b/gps/gnss/Agps.cpp
index 22582d4..72ce293 100644
--- a/gps/gnss/Agps.cpp
+++ b/gps/gnss/Agps.cpp
@@ -42,7 +42,7 @@ void AgpsStateMachine::processAgpsEvent(AgpsEvent event){
     LOC_LOGD("processAgpsEvent(): SM %p, Event %d, State %d",
                this, event, mState);
 
-    switch (event){
+    switch (event) {
 
         case AGPS_EVENT_SUBSCRIBE:
             processAgpsEventSubscribe();
@@ -71,7 +71,7 @@ void AgpsStateMachine::processAgpsEvent(AgpsEvent event){
 
 void AgpsStateMachine::processAgpsEventSubscribe(){
 
-    switch (mState){
+    switch (mState) {
 
         case AGPS_STATE_RELEASED:
             /* Add subscriber to list
@@ -83,7 +83,7 @@ void AgpsStateMachine::processAgpsEventSubscribe(){
              * fails for DS State Machine, we want to retry in released state.
              * for Agps State Machine, sendRsrcRequest() will always return
              * success. */
-            if(requestOrReleaseDataConn(true) == 0){
+            if (requestOrReleaseDataConn(true) == 0) {
                 // If data request successful, move to pending state
                 transitionState(AGPS_STATE_PENDING);
             }
@@ -115,7 +115,7 @@ void AgpsStateMachine::processAgpsEventSubscribe(){
 
 void AgpsStateMachine::processAgpsEventUnsubscribe(){
 
-    switch (mState){
+    switch (mState) {
 
         case AGPS_STATE_RELEASED:
             notifyEventToSubscriber(
@@ -127,12 +127,10 @@ void AgpsStateMachine::processAgpsEventUnsubscribe(){
             /* If the subscriber wishes to wait for connection close,
              * before being removed from list, move to inactive state
              * and notify */
-            if(mCurrentSubscriber->mWaitForCloseComplete){
+            if (mCurrentSubscriber->mWaitForCloseComplete) {
                 mCurrentSubscriber->mIsInactive = true;
-                notifyEventToSubscriber(
-                        AGPS_EVENT_UNSUBSCRIBE, mCurrentSubscriber, false);
             }
-            else{
+            else {
                 /* Notify only current subscriber and then delete it from
                  * subscriberList */
                 notifyEventToSubscriber(
@@ -140,13 +138,13 @@ void AgpsStateMachine::processAgpsEventUnsubscribe(){
             }
 
             /* If no subscribers in list, release data connection */
-            if(mSubscriberList.empty()){
+            if (mSubscriberList.empty()) {
                 transitionState(AGPS_STATE_RELEASED);
                 requestOrReleaseDataConn(false);
             }
             /* Some subscribers in list, but all inactive;
              * Release data connection */
-            else if(!anyActiveSubscribers()){
+            else if(!anyActiveSubscribers()) {
                 transitionState(AGPS_STATE_RELEASING);
                 requestOrReleaseDataConn(false);
             }
@@ -156,12 +154,10 @@ void AgpsStateMachine::processAgpsEventUnsubscribe(){
             /* If the subscriber wishes to wait for connection close,
              * before being removed from list, move to inactive state
              * and notify */
-            if(mCurrentSubscriber->mWaitForCloseComplete){
+            if (mCurrentSubscriber->mWaitForCloseComplete) {
                 mCurrentSubscriber->mIsInactive = true;
-                notifyEventToSubscriber(
-                        AGPS_EVENT_UNSUBSCRIBE, mCurrentSubscriber, false);
             }
-            else{
+            else {
                 /* Notify only current subscriber and then delete it from
                  * subscriberList */
                 notifyEventToSubscriber(
@@ -171,7 +167,7 @@ void AgpsStateMachine::processAgpsEventUnsubscribe(){
             /* If no subscribers in list, just move the state.
              * Request for releasing data connection should already have been
              * sent */
-            if(mSubscriberList.empty()){
+            if (mSubscriberList.empty()) {
                 transitionState(AGPS_STATE_RELEASED);
             }
             break;
@@ -183,7 +179,7 @@ void AgpsStateMachine::processAgpsEventUnsubscribe(){
 
 void AgpsStateMachine::processAgpsEventGranted(){
 
-    switch (mState){
+    switch (mState) {
 
         case AGPS_STATE_RELEASED:
         case AGPS_STATE_ACQUIRED:
@@ -206,7 +202,7 @@ void AgpsStateMachine::processAgpsEventGranted(){
 
 void AgpsStateMachine::processAgpsEventReleased(){
 
-    switch (mState){
+    switch (mState) {
 
         case AGPS_STATE_RELEASED:
             /* Subscriber list should be empty if we are in released state */
@@ -232,12 +228,12 @@ void AgpsStateMachine::processAgpsEventReleased(){
 
             /* If we have active subscribers now, they must be waiting for
              * data conn setup */
-            if(anyActiveSubscribers()){
+            if (anyActiveSubscribers()) {
                 transitionState(AGPS_STATE_PENDING);
                 requestOrReleaseDataConn(true);
             }
             /* No active subscribers, move to released state */
-            else{
+            else {
                 transitionState(AGPS_STATE_RELEASED);
             }
             break;
@@ -253,7 +249,7 @@ void AgpsStateMachine::processAgpsEventReleased(){
 
 void AgpsStateMachine::processAgpsEventDenied(){
 
-    switch (mState){
+    switch (mState) {
 
         case AGPS_STATE_RELEASED:
             LOC_LOGE("Unexpected event DENIED in state %d", mState);
@@ -271,12 +267,12 @@ void AgpsStateMachine::processAgpsEventDenied(){
 
             /* If we have active subscribers now, they must be waiting for
              * data conn setup */
-            if(anyActiveSubscribers()){
+            if (anyActiveSubscribers()) {
                 transitionState(AGPS_STATE_PENDING);
                 requestOrReleaseDataConn(true);
             }
             /* No active subscribers, move to released state */
-            else{
+            else {
                 transitionState(AGPS_STATE_RELEASED);
             }
             break;
@@ -299,20 +295,18 @@ void AgpsStateMachine::processAgpsEventDenied(){
  *      false = Release data connection */
 int AgpsStateMachine::requestOrReleaseDataConn(bool request){
 
-    AgpsFrameworkInterface::AGnssStatusIpV4 nifRequest;
+    AGnssExtStatusIpV4 nifRequest;
     memset(&nifRequest, 0, sizeof(nifRequest));
 
-    nifRequest.type = (AgpsFrameworkInterface::AGnssType)mAgpsType;
+    nifRequest.type = mAgpsType;
 
-    if(request){
+    if (request) {
         LOC_LOGD("AGPS Data Conn Request");
-        nifRequest.status = (AgpsFrameworkInterface::AGnssStatusValue)
-                                LOC_GPS_REQUEST_AGPS_DATA_CONN;
+        nifRequest.status = LOC_GPS_REQUEST_AGPS_DATA_CONN;
     }
     else{
         LOC_LOGD("AGPS Data Conn Release");
-        nifRequest.status = (AgpsFrameworkInterface::AGnssStatusValue)
-                                LOC_GPS_RELEASE_AGPS_DATA_CONN;
+        nifRequest.status = LOC_GPS_RELEASE_AGPS_DATA_CONN;
     }
 
     mAgpsManager->mFrameworkStatusV4Cb(nifRequest);
@@ -328,11 +322,11 @@ void AgpsStateMachine::notifyAllSubscribers(
             this, event, deleteSubscriberPostNotify, notificationType);
 
     std::list<AgpsSubscriber*>::const_iterator it = mSubscriberList.begin();
-    while ( it != mSubscriberList.end() ){
+    while ( it != mSubscriberList.end() ) {
 
         AgpsSubscriber* subscriber = *it;
 
-        if(notificationType == AGPS_NOTIFICATION_TYPE_FOR_ALL_SUBSCRIBERS ||
+        if (notificationType == AGPS_NOTIFICATION_TYPE_FOR_ALL_SUBSCRIBERS ||
                 (notificationType == AGPS_NOTIFICATION_TYPE_FOR_INACTIVE_SUBSCRIBERS &&
                         subscriber->mIsInactive) ||
                 (notificationType == AGPS_NOTIFICATION_TYPE_FOR_ACTIVE_SUBSCRIBERS &&
@@ -342,13 +336,13 @@ void AgpsStateMachine::notifyAllSubscribers(
              * through subscriber list, inefficient; hence pass in false*/
             notifyEventToSubscriber(event, subscriber, false);
 
-            if(deleteSubscriberPostNotify){
+            if (deleteSubscriberPostNotify) {
                 it = mSubscriberList.erase(it);
                 delete subscriber;
-            } else{
+            } else {
                 it++;
             }
-        } else{
+        } else {
             it++;
         }
     }
@@ -362,7 +356,7 @@ void AgpsStateMachine::notifyEventToSubscriber(
             "SM %p, Event %d Subscriber %p Delete %d",
             this, event, subscriberToNotify, deleteSubscriberPostNotify);
 
-    switch (event){
+    switch (event) {
 
         case AGPS_EVENT_GRANTED:
             mAgpsManager->mAtlOpenStatusCb(
@@ -409,9 +403,9 @@ void AgpsStateMachine::addSubscriber(AgpsSubscriber* subscriberToAdd){
     // Check if subscriber is already present in the current list
     // If not, then add
     std::list<AgpsSubscriber*>::const_iterator it = mSubscriberList.begin();
-    for(; it != mSubscriberList.end(); it++){
+    for (; it != mSubscriberList.end(); it++) {
         AgpsSubscriber* subscriber = *it;
-        if(subscriber->equals(subscriberToAdd)){
+        if (subscriber->equals(subscriberToAdd)) {
             LOC_LOGE("Subscriber already in list");
             return;
         }
@@ -431,11 +425,11 @@ void AgpsStateMachine::deleteSubscriber(AgpsSubscriber* subscriberToDelete){
     while ( it != mSubscriberList.end() ) {
 
         AgpsSubscriber* subscriber = *it;
-        if(subscriber && subscriber->equals(subscriberToDelete)){
+        if (subscriber && subscriber->equals(subscriberToDelete)) {
 
             it = mSubscriberList.erase(it);
             delete subscriber;
-        }else{
+        } else {
             it++;
         }
     }
@@ -444,9 +438,9 @@ void AgpsStateMachine::deleteSubscriber(AgpsSubscriber* subscriberToDelete){
 bool AgpsStateMachine::anyActiveSubscribers(){
 
     std::list<AgpsSubscriber*>::const_iterator it = mSubscriberList.begin();
-    for(; it != mSubscriberList.end(); it++){
+    for (; it != mSubscriberList.end(); it++) {
         AgpsSubscriber* subscriber = *it;
-        if(!subscriber->mIsInactive){
+        if (!subscriber->mIsInactive) {
             return true;
         }
     }
@@ -459,7 +453,7 @@ void AgpsStateMachine::setAPN(char* apn, unsigned int len){
         delete mAPN;
     }
 
-    if(apn == NULL || len <= 0){
+    if (apn == NULL || len <= 0) {
         LOC_LOGD("Invalid apn len (%d) or null apn", len);
         mAPN = NULL;
         mAPNLen = 0;
@@ -467,9 +461,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;
+        }
     }
 }
 
@@ -477,9 +473,9 @@ AgpsSubscriber* AgpsStateMachine::getSubscriber(int connHandle){
 
     /* Go over the subscriber list */
     std::list<AgpsSubscriber*>::const_iterator it = mSubscriberList.begin();
-    for(; it != mSubscriberList.end(); it++){
+    for (; it != mSubscriberList.end(); it++) {
         AgpsSubscriber* subscriber = *it;
-        if(subscriber->mConnHandle == connHandle){
+        if (subscriber->mConnHandle == connHandle) {
             return subscriber;
         }
     }
@@ -492,9 +488,9 @@ AgpsSubscriber* AgpsStateMachine::getFirstSubscriber(bool isInactive){
 
     /* Go over the subscriber list */
     std::list<AgpsSubscriber*>::const_iterator it = mSubscriberList.begin();
-    for(; it != mSubscriberList.end(); it++){
+    for (; it != mSubscriberList.end(); it++) {
         AgpsSubscriber* subscriber = *it;
-        if(subscriber->mIsInactive == isInactive){
+        if(subscriber->mIsInactive == isInactive) {
             return subscriber;
         }
     }
@@ -509,7 +505,7 @@ void AgpsStateMachine::dropAllSubscribers(){
 
     /* Go over the subscriber list */
     std::list<AgpsSubscriber*>::const_iterator it = mSubscriberList.begin();
-    while ( it != mSubscriberList.end() ){
+    while ( it != mSubscriberList.end() ) {
         AgpsSubscriber* subscriber = *it;
         it = mSubscriberList.erase(it);
         delete subscriber;
@@ -524,14 +520,14 @@ const int DSStateMachine::DATA_CALL_RETRY_DELAY_MSEC = 500;
 
 /* Overridden method
  * DS SM needs to handle one scenario differently */
-void DSStateMachine::processAgpsEvent(AgpsEvent event){
+void DSStateMachine::processAgpsEvent(AgpsEvent event) {
 
     LOC_LOGD("DSStateMachine::processAgpsEvent() %d", event);
 
     /* DS Client call setup APIs don't return failure/closure separately.
      * Hence we receive RELEASED event in both cases.
      * If we are in pending, we should consider RELEASED as DENIED */
-    if(event == AGPS_EVENT_RELEASED && mState == AGPS_STATE_PENDING){
+    if (event == AGPS_EVENT_RELEASED && mState == AGPS_STATE_PENDING) {
 
         LOC_LOGD("Translating RELEASED to DENIED event");
         event = AGPS_EVENT_DENIED;
@@ -549,7 +545,7 @@ void delay_callback(void *callbackData, int result)
 
     (void)result;
 
-    if(callbackData == NULL) {
+    if (callbackData == NULL) {
         LOC_LOGE("delay_callback(): NULL argument received !");
         return;
     }
@@ -566,7 +562,7 @@ void DSStateMachine :: retryCallback()
     /* Request SUPL ES
      * There must be at least one active subscriber in list */
     AgpsSubscriber* subscriber = getFirstSubscriber(false);
-    if(subscriber == NULL) {
+    if (subscriber == NULL) {
 
         LOC_LOGE("No active subscriber for DS Client call setup");
         return;
@@ -590,7 +586,7 @@ int DSStateMachine::requestOrReleaseDataConn(bool request){
              "request %d", request);
 
     /* Release data connection required ? */
-    if(!request && mAgpsManager->mDSClientStopDataCallFn){
+    if (!request && mAgpsManager->mDSClientStopDataCallFn) {
 
         mAgpsManager->mDSClientStopDataCallFn();
         LOC_LOGD("DS Client release data call request sent !");
@@ -600,14 +596,14 @@ int DSStateMachine::requestOrReleaseDataConn(bool request){
     /* Setup data connection request
      * There must be at least one active subscriber in list */
     AgpsSubscriber* subscriber = getFirstSubscriber(false);
-    if(subscriber == NULL) {
+    if (subscriber == NULL) {
 
         LOC_LOGE("No active subscriber for DS Client call setup");
         return -1;
     }
 
     /* DS Client Fn registered ? */
-    if(!mAgpsManager->mDSClientOpenAndStartDataCallFn){
+    if (!mAgpsManager->mDSClientOpenAndStartDataCallFn) {
 
         LOC_LOGE("DS Client start fn not registered, fallback to SUPL ATL");
         notifyEventToSubscriber(AGPS_EVENT_DENIED, subscriber, false);
@@ -623,7 +619,7 @@ int DSStateMachine::requestOrReleaseDataConn(bool request){
         case LOC_API_ADAPTER_ERR_ENGINE_BUSY:
             LOC_LOGE("DS Client open call failed, err: %d", ret);
             mRetries++;
-            if(mRetries > MAX_START_DATA_CALL_RETRIES) {
+            if (mRetries > MAX_START_DATA_CALL_RETRIES) {
 
                 LOC_LOGE("DS Client call retries exhausted, "
                          "falling back to normal SUPL ATL");
@@ -661,7 +657,7 @@ void DSStateMachine::notifyEventToSubscriber(
              "SM %p, Event %d Subscriber %p Delete %d",
              this, event, subscriberToNotify, deleteSubscriberPostNotify);
 
-    switch (event){
+    switch (event) {
 
         case AGPS_EVENT_GRANTED:
             mAgpsManager->mAtlOpenStatusCb(
@@ -685,6 +681,7 @@ void DSStateMachine::notifyEventToSubscriber(
 
         case AGPS_EVENT_RELEASED:
             mAgpsManager->mDSClientCloseDataCallFn();
+            mAgpsManager->mAtlCloseStatusCb(subscriberToNotify->mConnHandle, 1);
             break;
 
         default:
@@ -721,14 +718,14 @@ void AgpsManager::createAgpsStateMachines() {
             LOC_LOGD("AGNSS NIF: %p", mAgnssNif);
         }
         if (NULL == mDsNif &&
-                loc_core::ContextBase::mGps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL){
+                loc_core::ContextBase::mGps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL) {
 
             if(!mDSClientInitFn){
 
                 LOC_LOGE("DS Client Init Fn not registered !");
                 return;
             }
-            if(mDSClientInitFn(false) != 0){
+            if (mDSClientInitFn(false) != 0) {
 
                 LOC_LOGE("Failed to init data service client");
                 return;
@@ -747,7 +744,7 @@ AgpsStateMachine* AgpsManager::getAgpsStateMachine(AGpsExtType agpsType) {
 
         case LOC_AGPS_TYPE_INVALID:
         case LOC_AGPS_TYPE_SUPL:
-            if(mAgnssNif == NULL){
+            if (mAgnssNif == NULL) {
                 LOC_LOGE("NULL AGNSS NIF !");
             }
             return mAgnssNif;
@@ -777,7 +774,7 @@ void AgpsManager::requestATL(int connHandle, AGpsExtType agpsType){
 
     AgpsStateMachine* sm = getAgpsStateMachine(agpsType);
 
-    if(sm == NULL){
+    if (sm == NULL) {
 
         LOC_LOGE("No AGPS State Machine for agpsType: %d", agpsType);
         mAtlOpenStatusCb(
@@ -790,7 +787,7 @@ void AgpsManager::requestATL(int connHandle, AGpsExtType agpsType){
     sm->setCurrentSubscriber(&subscriber);
 
     /* If DS State Machine, wait for close complete */
-    if(agpsType == LOC_AGPS_TYPE_SUPL_ES){
+    if (agpsType == LOC_AGPS_TYPE_SUPL_ES) {
         subscriber.mWaitForCloseComplete = true;
     }
 
@@ -820,7 +817,7 @@ void AgpsManager::releaseATL(int connHandle){
         sm = mDsNif;
     }
 
-    if(sm == NULL){
+    if (sm == NULL) {
         LOC_LOGE("Subscriber with connHandle %d not found in any SM",
                     connHandle);
         mAtlCloseStatusCb(connHandle, 0);
@@ -852,32 +849,15 @@ void AgpsManager::reportDataCallClosed(){
 
 void AgpsManager::reportAtlOpenSuccess(
         AGpsExtType agpsType, char* apnName, int apnLen,
-        LocApnIpType ipType){
+        AGpsBearerType bearerType){
 
     LOC_LOGD("AgpsManager::reportAtlOpenSuccess(): "
-             "AgpsType %d, APN [%s], Len %d, IPType %d",
-             agpsType, apnName, apnLen, ipType);
+             "AgpsType %d, APN [%s], Len %d, BearerType %d",
+             agpsType, apnName, apnLen, bearerType);
 
     /* Find the state machine instance */
     AgpsStateMachine* sm = getAgpsStateMachine(agpsType);
 
-    /* Convert LocApnIpType sent by framework to AGpsBearerType */
-    AGpsBearerType bearerType;
-    switch (ipType) {
-        case LOC_APN_IP_IPV4:
-            bearerType = AGPS_APN_BEARER_IPV4;
-            break;
-        case LOC_APN_IP_IPV6:
-            bearerType = AGPS_APN_BEARER_IPV6;
-            break;
-        case LOC_APN_IP_IPV4V6:
-            bearerType = AGPS_APN_BEARER_IPV4V6;
-            break;
-        default:
-            bearerType = AGPS_APN_BEARER_IPV4;
-            break;
-    }
-
     /* Set bearer and apn info in state machine instance */
     sm->setBearer(bearerType);
     sm->setAPN(apnName, apnLen);
@@ -909,19 +889,19 @@ void AgpsManager::handleModemSSR(){
     LOC_LOGD("AgpsManager::handleModemSSR");
 
     /* Drop subscribers from all state machines */
-    if (mAgnssNif){
+    if (mAgnssNif) {
         mAgnssNif->dropAllSubscribers();
     }
-    if (mInternetNif){
+    if (mInternetNif) {
         mInternetNif->dropAllSubscribers();
     }
-    if(mDsNif){
+    if (mDsNif) {
         mDsNif->dropAllSubscribers();
     }
 
     // reinitialize DS client in SSR mode
-    if(loc_core::ContextBase::mGps_conf.
-            USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL){
+    if (loc_core::ContextBase::mGps_conf.
+            USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL) {
 
         mDSClientStopDataCallFn();
         mDSClientCloseDataCallFn();
@@ -930,39 +910,3 @@ void AgpsManager::handleModemSSR(){
         mDSClientInitFn(true);
     }
 }
-
-AGpsBearerType AgpsUtils::ipTypeToBearerType(LocApnIpType ipType) {
-
-    switch (ipType) {
-
-        case LOC_APN_IP_IPV4:
-            return AGPS_APN_BEARER_IPV4;
-
-        case LOC_APN_IP_IPV6:
-            return AGPS_APN_BEARER_IPV6;
-
-        case LOC_APN_IP_IPV4V6:
-            return AGPS_APN_BEARER_IPV4V6;
-
-        default:
-            return AGPS_APN_BEARER_IPV4;
-    }
-}
-
-LocApnIpType AgpsUtils::bearerTypeToIpType(AGpsBearerType bearerType){
-
-    switch (bearerType) {
-
-        case AGPS_APN_BEARER_IPV4:
-            return LOC_APN_IP_IPV4;
-
-        case AGPS_APN_BEARER_IPV6:
-            return LOC_APN_IP_IPV6;
-
-        case AGPS_APN_BEARER_IPV4V6:
-            return LOC_APN_IP_IPV4V6;
-
-        default:
-            return LOC_APN_IP_IPV4;
-    }
-}
diff --git a/gps/gnss/Agps.h b/gps/gnss/Agps.h
index d3fc362..2f89c8c 100644
--- a/gps/gnss/Agps.h
+++ b/gps/gnss/Agps.h
@@ -87,70 +87,6 @@ typedef enum {
     AGPS_NOTIFICATION_TYPE_FOR_ACTIVE_SUBSCRIBERS
 } AgpsNotificationType;
 
-/* Framework AGNSS interface
- * This interface is defined in IAGnssCallback provided by
- * Android Framework.
- * Must be kept in sync with that interface. */
-namespace AgpsFrameworkInterface {
-
-    /** AGNSS type **/
-    enum AGnssType : uint8_t {
-        TYPE_SUPL         = 1,
-        TYPE_C2K          = 2
-    };
-
-    enum AGnssStatusValue : uint8_t {
-        /** GNSS requests data connection for AGNSS. */
-        REQUEST_AGNSS_DATA_CONN  = 1,
-        /** GNSS releases the AGNSS data connection. */
-        RELEASE_AGNSS_DATA_CONN  = 2,
-        /** AGNSS data connection initiated */
-        AGNSS_DATA_CONNECTED     = 3,
-        /** AGNSS data connection completed */
-        AGNSS_DATA_CONN_DONE     = 4,
-        /** AGNSS data connection failed */
-        AGNSS_DATA_CONN_FAILED   = 5
-    };
-
-    /*
-     * Represents the status of AGNSS augmented to support IPv4.
-     */
-    struct AGnssStatusIpV4 {
-        AGnssType type;
-        AGnssStatusValue status;
-        /*
-         * 32-bit IPv4 address.
-         */
-        unsigned int ipV4Addr;
-    };
-
-    /*
-     * Represents the status of AGNSS augmented to support IPv6.
-     */
-    struct AGnssStatusIpV6 {
-        AGnssType type;
-        AGnssStatusValue status;
-        /*
-         * 128-bit IPv6 address.
-         */
-        unsigned char ipV6Addr[16];
-    };
-
-    /*
-     * Callback with AGNSS(IpV4) status information.
-     *
-     * @param status Will be of type AGnssStatusIpV4.
-     */
-    typedef void (*AgnssStatusIpV4Cb)(AGnssStatusIpV4 status);
-
-    /*
-     * Callback with AGNSS(IpV6) status information.
-     *
-     * @param status Will be of type AGnssStatusIpV6.
-     */
-    typedef void (*AgnssStatusIpV6Cb)(AGnssStatusIpV6 status);
-}
-
 /* Classes in this header */
 class AgpsSubscriber;
 class AgpsManager;
@@ -342,8 +278,7 @@ public:
 
     /* Register callbacks */
     void registerCallbacks(
-            AgpsFrameworkInterface::AgnssStatusIpV4Cb
-                                                frameworkStatusV4Cb,
+            AgnssStatusIpV4Cb                   frameworkStatusV4Cb,
 
             AgpsAtlOpenStatusCb                 atlOpenStatusCb,
             AgpsAtlCloseStatusCb                atlCloseStatusCb,
@@ -382,9 +317,8 @@ public:
     void reportDataCallClosed();
 
     /* Process incoming framework data call events */
-    void reportAtlOpenSuccess(
-            AGpsExtType agpsType, char* apnName, int apnLen,
-            LocApnIpType ipType);
+    void reportAtlOpenSuccess(AGpsExtType agpsType, char* apnName, int apnLen,
+            AGpsBearerType bearerType);
     void reportAtlOpenFailed(AGpsExtType agpsType);
     void reportAtlClosed(AGpsExtType agpsType);
 
@@ -392,7 +326,7 @@ public:
     void handleModemSSR();
 
 protected:
-    AgpsFrameworkInterface::AgnssStatusIpV4Cb mFrameworkStatusV4Cb;
+    AgnssStatusIpV4Cb     mFrameworkStatusV4Cb;
 
     AgpsAtlOpenStatusCb   mAtlOpenStatusCb;
     AgpsAtlCloseStatusCb  mAtlCloseStatusCb;
diff --git a/gps/gnss/GnssAdapter.cpp b/gps/gnss/GnssAdapter.cpp
index 7e638ad..cdda01d 100644
--- a/gps/gnss/GnssAdapter.cpp
+++ b/gps/gnss/GnssAdapter.cpp
@@ -44,12 +44,20 @@
 #include <Agps.h>
 #include <SystemStatus.h>
 
-#include <loc_nmea.h>
 #include <vector>
-#include <string>
+
+#define RAD2DEG    (180.0 / M_PI)
 
 using namespace loc_core;
 
+/* Method to fetch status cb from loc_net_iface library */
+typedef AgpsCbInfo& (*LocAgpsGetAgpsCbInfo)(LocAgpsOpenResultCb openResultCb,
+        LocAgpsCloseResultCb closeResultCb, void* userDataPtr);
+
+static void agpsOpenResultCb (bool isSuccess, AGpsExtType agpsType, const char* apn,
+        AGpsBearerType bearerType, void* userDataPtr);
+static void agpsCloseResultCb (bool isSuccess, AGpsExtType agpsType, void* userDataPtr);
+
 GnssAdapter::GnssAdapter() :
     LocAdapterBase(0,
                    LocDualContext::getLocFgContext(NULL,
@@ -66,12 +74,15 @@ GnssAdapter::GnssAdapter() :
     mNiData(),
     mAgpsManager(),
     mAgpsCbInfo(),
-    mSystemStatus(SystemStatus::getInstance(mMsgTask))
+    mSystemStatus(SystemStatus::getInstance(mMsgTask)),
+    mServerUrl(""),
+    mXtraObserver(mSystemStatus->getOsObserver(), mMsgTask)
 {
     LOC_LOGD("%s]: Constructor %p", __func__, this);
     mUlpPositionMode.mode = LOC_POSITION_MODE_INVALID;
     readConfigCommand();
     setConfigCommand();
+    initDefaultAgpsCommand();
 }
 
 void
@@ -601,6 +612,10 @@ GnssAdapter::gnssUpdateConfigCommand(GnssConfig config)
     uint32_t* ids = NULL;
     if (count > 0) {
         ids = new uint32_t[count];
+        if (ids == nullptr) {
+            LOC_LOGE("%s] new allocation failed, fatal error.", __func__);
+            return nullptr;
+        }
         for (size_t i=0; i < count; ++i) {
             ids[i] = generateSessionId();
             IF_LOC_LOGD {
@@ -634,12 +649,15 @@ 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;
 
+            if (errs == nullptr) {
+                LOC_LOGE("%s] new allocation failed, fatal error.", __func__);
+                return;
+            }
+
             if (mConfig.flags & GNSS_CONFIG_FLAGS_GPS_LOCK_VALID_BIT) {
                 uint32_t newGpsLock = mAdapter.convertGpsLock(mConfig.gpsLock);
                 ContextBase::mGps_conf.GPS_LOCK = newGpsLock;
@@ -667,30 +685,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;
@@ -1244,6 +1265,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)
 {
@@ -1409,8 +1439,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);
+            }
         }
     };
 
@@ -1433,8 +1464,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);
+            }
         }
     };
 
@@ -2109,6 +2142,10 @@ GnssAdapter::reportNmeaEvent(const char* nmea, size_t length, bool fromUlp)
             mAdapter(adapter),
             mNmea(new char[length+1]),
             mLength(length) {
+                if (mNmea == nullptr) {
+                    LOC_LOGE("%s] new allocation failed, fatal error.", __func__);
+                    return;
+                }
                 strlcpy((char*)mNmea, nmea, length+1);
             }
         inline virtual ~MsgReportNmea()
@@ -2370,6 +2407,57 @@ GnssAdapter::reportSvPolynomialEvent(GnssSvPolynomial &svPolynomial)
     mUlpProxy->reportSvPolynomial(svPolynomial);
 }
 
+void GnssAdapter::initDefaultAgps() {
+    LOC_LOGD("%s]: ", __func__);
+
+    LocationCapabilitiesMask mask = getCapabilities();
+    if (!(mask & LOCATION_CAPABILITIES_GNSS_MSB_BIT) &&
+            !(mask & LOCATION_CAPABILITIES_GNSS_MSA_BIT)) {
+        LOC_LOGI("%s]: Target does not support MSB and MSA.", __func__);
+        return;
+    }
+
+    void *handle = nullptr;
+    if ((handle = dlopen("libloc_net_iface.so", RTLD_NOW)) == nullptr) {
+        LOC_LOGE("%s]: libloc_net_iface.so not found !", __func__);
+        return;
+    }
+
+    LocAgpsGetAgpsCbInfo getAgpsCbInfo = (LocAgpsGetAgpsCbInfo)
+            dlsym(handle, "LocNetIfaceAgps_getAgpsCbInfo");
+    if (getAgpsCbInfo == nullptr) {
+        LOC_LOGE("%s]: Failed to get method LocNetIfaceAgps_getStatusCb", __func__);
+        return;
+    }
+
+    AgpsCbInfo& cbInfo = getAgpsCbInfo(agpsOpenResultCb, agpsCloseResultCb, this);
+
+    if (cbInfo.statusV4Cb == nullptr) {
+        LOC_LOGE("%s]: statusV4Cb is nullptr!", __func__);
+        return;
+    }
+
+    initAgpsCommand(cbInfo);
+}
+
+void GnssAdapter::initDefaultAgpsCommand() {
+    LOC_LOGD("%s]: ", __func__);
+
+    struct MsgInitDefaultAgps : public LocMsg {
+        GnssAdapter& mAdapter;
+        inline MsgInitDefaultAgps(GnssAdapter& adapter) :
+            LocMsg(),
+            mAdapter(adapter) {
+                LOC_LOGV("MsgInitDefaultAgps");
+            }
+        inline virtual void proc() const {
+            mAdapter.initDefaultAgps();
+        }
+    };
+
+    sendMsg(new MsgInitDefaultAgps(*this));
+}
+
 /* INIT LOC AGPS MANAGER */
 void GnssAdapter::initAgpsCommand(const AgpsCbInfo& cbInfo){
 
@@ -2432,7 +2520,7 @@ void GnssAdapter::initAgpsCommand(const AgpsCbInfo& cbInfo){
 
         AgpsManager* mAgpsManager;
 
-        AgpsFrameworkInterface::AgnssStatusIpV4Cb mFrameworkStatusV4Cb;
+        AgnssStatusIpV4Cb mFrameworkStatusV4Cb;
 
         AgpsAtlOpenStatusCb mAtlOpenStatusCb;
         AgpsAtlCloseStatusCb mAtlCloseStatusCb;
@@ -2447,7 +2535,7 @@ void GnssAdapter::initAgpsCommand(const AgpsCbInfo& cbInfo){
         GnssAdapter& mAdapter;
 
         inline AgpsMsgInit(AgpsManager* agpsManager,
-                AgpsFrameworkInterface::AgnssStatusIpV4Cb frameworkStatusV4Cb,
+                AgnssStatusIpV4Cb frameworkStatusV4Cb,
                 AgpsAtlOpenStatusCb atlOpenStatusCb,
                 AgpsAtlCloseStatusCb atlCloseStatusCb,
                 AgpsDSClientInitFn dsClientInitFn,
@@ -2499,7 +2587,7 @@ void GnssAdapter::initAgpsCommand(const AgpsCbInfo& cbInfo){
     /* Send message to initialize AGPS Manager */
     sendMsg(new AgpsMsgInit(
                 &mAgpsManager,
-                (AgpsFrameworkInterface::AgnssStatusIpV4Cb)cbInfo.statusV4Cb,
+                (AgnssStatusIpV4Cb)cbInfo.statusV4Cb,
                 atlOpenStatusCb, atlCloseStatusCb,
                 dsClientInitFn, dsClientOpenAndStartDataCallFn,
                 dsClientStopDataCallFn, dsClientCloseDataCallFn,
@@ -2631,7 +2719,7 @@ bool GnssAdapter::reportDataCallClosed(){
 
 void GnssAdapter::dataConnOpenCommand(
         AGpsExtType agpsType,
-        const char* apnName, int apnLen, LocApnIpType ipType){
+        const char* apnName, int apnLen, AGpsBearerType bearerType){
 
     LOC_LOGI("GnssAdapter::frameworkDataConnOpen");
 
@@ -2641,14 +2729,18 @@ void GnssAdapter::dataConnOpenCommand(
         AGpsExtType mAgpsType;
         char* mApnName;
         int mApnLen;
-        LocApnIpType mIpType;
+        AGpsBearerType mBearerType;
 
         inline AgpsMsgAtlOpenSuccess(AgpsManager* agpsManager, AGpsExtType agpsType,
-                const char* apnName, int apnLen, LocApnIpType ipType) :
+                const char* apnName, int apnLen, AGpsBearerType bearerType) :
                 LocMsg(), mAgpsManager(agpsManager), mAgpsType(agpsType), mApnName(
-                        new char[apnLen + 1]), mApnLen(apnLen), mIpType(ipType) {
+                        new char[apnLen + 1]), mApnLen(apnLen), mBearerType(bearerType) {
 
             LOC_LOGV("AgpsMsgAtlOpenSuccess");
+            if (mApnName == nullptr) {
+                LOC_LOGE("%s] new allocation failed, fatal error.", __func__);
+                return;
+            }
             memcpy(mApnName, apnName, apnLen);
             mApnName[apnLen] = 0;
         }
@@ -2660,13 +2752,12 @@ void GnssAdapter::dataConnOpenCommand(
         inline virtual void proc() const {
 
             LOC_LOGV("AgpsMsgAtlOpenSuccess::proc()");
-            mAgpsManager->reportAtlOpenSuccess(mAgpsType, mApnName, mApnLen,
-                    mIpType);
+            mAgpsManager->reportAtlOpenSuccess(mAgpsType, mApnName, mApnLen, mBearerType);
         }
     };
 
     sendMsg( new AgpsMsgAtlOpenSuccess(
-            &mAgpsManager, (AGpsExtType)agpsType, apnName, apnLen, ipType));
+            &mAgpsManager, agpsType, apnName, apnLen, bearerType));
 }
 
 void GnssAdapter::dataConnClosedCommand(AGpsExtType agpsType){
@@ -2897,16 +2988,12 @@ bool GnssAdapter::getDebugReport(GnssDebugReport& r)
     }
     else if(!reports.mBestPosition.empty() && reports.mBestPosition.back().mValid) {
         r.mLocation.mValid = true;
-        r.mLocation.mLocation.latitude  =
-            (double)(reports.mBestPosition.back().mBestLat);
+        r.mLocation.mLocation.latitude =
+                (double)(reports.mBestPosition.back().mBestLat) * RAD2DEG;
         r.mLocation.mLocation.longitude =
-            (double)(reports.mBestPosition.back().mBestLon);
-        r.mLocation.mLocation.altitude  =
-            reports.mBestPosition.back().mBestAlt;
-
-        r.mLocation.mLocation.timestamp =
-            reports.mBestPosition.back().mUtcReported.tv_sec * 1000ULL +
-            reports.mBestPosition.back().mUtcReported.tv_nsec / 1000000ULL;
+                (double)(reports.mBestPosition.back().mBestLon) * RAD2DEG;
+        r.mLocation.mLocation.altitude = reports.mBestPosition.back().mBestAlt;
+        r.mLocation.mUtcReported = reports.mBestPosition.back().mUtcReported;
     }
     else {
         r.mLocation.mValid = false;
@@ -3009,3 +3096,36 @@ GnssAdapter::getAgcInformation(GnssMeasurementsNotification& measurements, int m
     }
 }
 
+/* Callbacks registered with loc_net_iface library */
+static void agpsOpenResultCb (bool isSuccess, AGpsExtType agpsType, const char* apn,
+        AGpsBearerType bearerType, void* userDataPtr) {
+    LOC_LOGD("%s]: ", __func__);
+    if (userDataPtr == nullptr) {
+        LOC_LOGE("%s]: userDataPtr is nullptr.", __func__);
+        return;
+    }
+    if (apn == nullptr) {
+        LOC_LOGE("%s]: apn is nullptr.", __func__);
+        return;
+    }
+    GnssAdapter* adapter = (GnssAdapter*)userDataPtr;
+    if (isSuccess) {
+        adapter->dataConnOpenCommand(agpsType, apn, strlen(apn), bearerType);
+    } else {
+        adapter->dataConnFailedCommand(agpsType);
+    }
+}
+
+static void agpsCloseResultCb (bool isSuccess, AGpsExtType agpsType, void* userDataPtr) {
+    LOC_LOGD("%s]: ", __func__);
+    if (userDataPtr == nullptr) {
+        LOC_LOGE("%s]: userDataPtr is nullptr.", __func__);
+        return;
+    }
+    GnssAdapter* adapter = (GnssAdapter*)userDataPtr;
+    if (isSuccess) {
+        adapter->dataConnClosedCommand(agpsType);
+    } else {
+        adapter->dataConnFailedCommand(agpsType);
+    }
+}
diff --git a/gps/gnss/GnssAdapter.h b/gps/gnss/GnssAdapter.h
index 46ba34f..e7605f9 100644
--- a/gps/gnss/GnssAdapter.h
+++ b/gps/gnss/GnssAdapter.h
@@ -106,10 +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);
@@ -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);
@@ -198,10 +199,10 @@ public:
     uint32_t* gnssUpdateConfigCommand(GnssConfig config);
     uint32_t gnssDeleteAidingDataCommand(GnssAidingData& data);
 
+    void initDefaultAgpsCommand();
     void initAgpsCommand(const AgpsCbInfo& cbInfo);
-    void dataConnOpenCommand(
-            AGpsExtType agpsType,
-            const char* apnName, int apnLen, LocApnIpType ipType);
+    void dataConnOpenCommand(AGpsExtType agpsType,
+            const char* apnName, int apnLen, AGpsBearerType bearerType);
     void dataConnClosedCommand(AGpsExtType agpsType);
     void dataConnFailedCommand(AGpsExtType agpsType);
 
@@ -215,6 +216,8 @@ 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(); }
+    void initDefaultAgps();
 
     /* ==== REPORTS ======================================================================== */
     /* ======== EVENTS ====(Called from QMI/ULP Thread)===================================== */
@@ -254,6 +257,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);
@@ -277,10 +282,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/gps/gnss/XtraSystemStatusObserver.cpp b/gps/gnss/XtraSystemStatusObserver.cpp
index 58a8522..ce08f64 100644
--- a/gps/gnss/XtraSystemStatusObserver.cpp
+++ b/gps/gnss/XtraSystemStatusObserver.cpp
@@ -45,40 +45,55 @@
 #include <sstream>
 #include <XtraSystemStatusObserver.h>
 #include <LocAdapterBase.h>
+#include <DataItemId.h>
+#include <DataItemsFactoryProxy.h>
 
-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::updateMccMnc(const string& mccmnc) {
+    stringstream ss;
+    ss <<  "mncmcc";
+    ss << " " << mccmnc.c_str();
+    ss << "\n"; // append seperator
+    return ( sendEvent(ss) );
+}
 
-bool XtraSystemStatusObserver::sendEvent(std::stringstream& event) {
+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<DataItemId> subItemIdList;
+    subItemIdList.push_back(NETWORKINFO_DATA_ITEM_ID);
+    subItemIdList.push_back(MCCMNC_DATA_ITEM_ID);
+
+    if (yes) {
+        mSystemStatusObsrvr->subscribe(subItemIdList, this);
+
+        list<DataItemId> 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<IDataItemCore*>& dlist)
+{
+    struct handleOsObserverUpdateMsg : public LocMsg {
+        XtraSystemStatusObserver* mXtraSysStatObj;
+        list <IDataItemCore*> mDataItemList;
+
+        inline handleOsObserverUpdateMsg(XtraSystemStatusObserver* xtraSysStatObs,
+                const list<IDataItemCore*>& 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<SystemStatusNetworkInfo*>(each);
+                        mXtraSysStatObj->updateConnectionStatus(networkInfo->mConnected,
+                                networkInfo->mType);
+                    }
+                    break;
+
+                    case TAC_DATA_ITEM_ID:
+                    {
+                        SystemStatusTac* tac = reinterpret_cast<SystemStatusTac*>(each);
+                        mXtraSysStatObj->updateTac(tac->mValue);
+                    }
+                    break;
+
+                    case MCCMNC_DATA_ITEM_ID:
+                    {
+                        SystemStatusMccMnc* mccmnc = reinterpret_cast<SystemStatusMccMnc*>(each);
+                        mXtraSysStatObj->updateMccMnc(mccmnc->mValue);
+                    }
+                    break;
+
+                    default:
+                    break;
+                }
+            }
+        }
+    };
+    mMsgTask->sendMsg(new (nothrow) handleOsObserverUpdateMsg(this, dlist));
+}
+
+
diff --git a/gps/gnss/XtraSystemStatusObserver.h b/gps/gnss/XtraSystemStatusObserver.h
index e49f17b..42f49b5 100644
--- a/gps/gnss/XtraSystemStatusObserver.h
+++ b/gps/gnss/XtraSystemStatusObserver.h
@@ -29,25 +29,42 @@
 #ifndef XTRA_SYSTEM_STATUS_OBS_H
 #define XTRA_SYSTEM_STATUS_OBS_H
 
-#include <stdint.h>
+#include <cinttypes>
+#include <MsgTask.h>
 
+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<IDataItemCore*>& 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/gps/gnss/location_gnss.cpp b/gps/gnss/location_gnss.cpp
index a99d8ef..b5623e1 100644
--- a/gps/gnss/location_gnss.cpp
+++ b/gps/gnss/location_gnss.cpp
@@ -228,7 +228,7 @@ static void agpsDataConnOpen(
 
     if (NULL != gGnssAdapter) {
         gGnssAdapter->dataConnOpenCommand(
-                agpsType, apnName, apnLen, ipType);
+                agpsType, apnName, apnLen, (AGpsBearerType)ipType);
     }
 }
 static void agpsDataConnClosed(AGpsExtType agpsType) {
@@ -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
+}