Merge remote-tracking branch 'goog/qcom/release/LA.UM.8.1.R1.09.00.00.529.074' into qt-qpr1-dev

Bug: 138911886
Change-Id: I7e6193ff40e1ce775c54bdafcf8acc1a4eb42c43

31 files changed, 764 insertions, 617 deletions

diff --git a/Android.mk b/Android.mk
index a995aff..f1088a4 100644
--- a/Android.mk
+++ b/Android.mk
@@ -1,7 +1,5 @@
+ifneq ($(BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE),)
 LOCAL_PATH := $(call my-dir)
 include $(LOCAL_PATH)/build/target_specific_features.mk
-ifneq ($(BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE),)
 include $(call all-makefiles-under,$(LOCAL_PATH))
-else
-include $(LOCAL_PATH)/android/Android.mk
 endif
diff --git a/android/1.0/AGnssRil.cpp b/android/1.0/AGnssRil.cpp
index 0ab4fad..0437cf1 100644
--- a/android/1.0/AGnssRil.cpp
+++ b/android/1.0/AGnssRil.cpp
@@ -102,7 +102,7 @@ Return<bool> AGnssRil::updateNetworkState(bool connected, NetworkType type, bool
                 }
                 break;
         }
-        mGnss->getGnssInterface()->updateConnectionStatus(connected, typeout);
+        mGnss->getGnssInterface()->updateConnectionStatus(connected, false, typeout, 0);
     }
     return true;
 }
diff --git a/android/1.0/service.cpp b/android/1.0/service.cpp
index 04bb8ab..2a6f60f 100644
--- a/android/1.0/service.cpp
+++ b/android/1.0/service.cpp
@@ -48,7 +48,8 @@ int main() {
 
     ALOGI("%s", __FUNCTION__);
 
-    bool vendorEnhanced = isRunningWithVendorEnhancedFramework();
+    int vendorInfo = getVendorEnhancedInfo();
+    bool vendorEnhanced = ( 1 == vendorInfo || 3 == vendorInfo );
     setVendorEnhanced(vendorEnhanced);
 
 #ifdef ARCH_ARM_32
diff --git a/android/1.1/AGnssRil.cpp b/android/1.1/AGnssRil.cpp
index 96e3597..1e774f1 100644
--- a/android/1.1/AGnssRil.cpp
+++ b/android/1.1/AGnssRil.cpp
@@ -102,7 +102,7 @@ Return<bool> AGnssRil::updateNetworkState(bool connected, NetworkType type, bool
                 }
                 break;
         }
-        mGnss->getGnssInterface()->updateConnectionStatus(connected, typeout);
+        mGnss->getGnssInterface()->updateConnectionStatus(connected, false, typeout, 0);
     }
     return true;
 }
diff --git a/android/1.1/service.cpp b/android/1.1/service.cpp
index bf7ad07..0cb91f7 100644
--- a/android/1.1/service.cpp
+++ b/android/1.1/service.cpp
@@ -48,7 +48,8 @@ int main() {
 
     ALOGI("%s", __FUNCTION__);
 
-    bool vendorEnhanced = isRunningWithVendorEnhancedFramework();
+    int vendorInfo = getVendorEnhancedInfo();
+    bool vendorEnhanced = ( 1 == vendorInfo || 3 == vendorInfo );
     setVendorEnhanced(vendorEnhanced);
 
 #ifdef ARCH_ARM_32
diff --git a/android/2.0/AGnssRil.cpp b/android/2.0/AGnssRil.cpp
index 9de8b7d..a477fc2 100644
--- a/android/2.0/AGnssRil.cpp
+++ b/android/2.0/AGnssRil.cpp
@@ -57,29 +57,29 @@ Return<bool> AGnssRil::updateNetworkState(bool connected, NetworkType type, bool
 
     // for XTRA
     if (nullptr != mGnss && ( nullptr != mGnss->getGnssInterface() )) {
-        int8_t typeout = loc_core::NetworkInfoDataItemBase::TYPE_UNKNOWN;
+        int8_t typeout = loc_core::TYPE_UNKNOWN;
         switch(type)
         {
             case IAGnssRil::NetworkType::MOBILE:
-                typeout = loc_core::NetworkInfoDataItemBase::TYPE_MOBILE;
+                typeout = loc_core::TYPE_MOBILE;
                 break;
             case IAGnssRil::NetworkType::WIFI:
-                typeout = loc_core::NetworkInfoDataItemBase::TYPE_WIFI;
+                typeout = loc_core::TYPE_WIFI;
                 break;
             case IAGnssRil::NetworkType::MMS:
-                typeout = loc_core::NetworkInfoDataItemBase::TYPE_MMS;
+                typeout = loc_core::TYPE_MMS;
                 break;
             case IAGnssRil::NetworkType::SUPL:
-                typeout = loc_core::NetworkInfoDataItemBase::TYPE_SUPL;
+                typeout = loc_core::TYPE_SUPL;
                 break;
             case IAGnssRil::NetworkType::DUN:
-                typeout = loc_core::NetworkInfoDataItemBase::TYPE_DUN;
+                typeout = loc_core::TYPE_DUN;
                 break;
             case IAGnssRil::NetworkType::HIPRI:
-                typeout = loc_core::NetworkInfoDataItemBase::TYPE_HIPRI;
+                typeout = loc_core::TYPE_HIPRI;
                 break;
             case IAGnssRil::NetworkType::WIMAX:
-                typeout = loc_core::NetworkInfoDataItemBase::TYPE_WIMAX;
+                typeout = loc_core::TYPE_WIMAX;
                 break;
             default:
                 {
@@ -88,16 +88,16 @@ Return<bool> AGnssRil::updateNetworkState(bool connected, NetworkType type, bool
                     switch(networkType)
                     {
                         case NetworkType_BLUETOOTH:
-                            typeout = loc_core::NetworkInfoDataItemBase::TYPE_BLUETOOTH;
+                            typeout = loc_core::TYPE_BLUETOOTH;
                             break;
                         case NetworkType_ETHERNET:
-                            typeout = loc_core::NetworkInfoDataItemBase::TYPE_ETHERNET;
+                            typeout = loc_core::TYPE_ETHERNET;
                             break;
                         case NetworkType_PROXY:
-                            typeout = loc_core::NetworkInfoDataItemBase::TYPE_PROXY;
+                            typeout = loc_core::TYPE_PROXY;
                             break;
                         default:
-                            typeout = loc_core::NetworkInfoDataItemBase::TYPE_UNKNOWN;
+                            typeout = loc_core::TYPE_UNKNOWN;
                     }
                 }
                 break;
@@ -110,12 +110,12 @@ Return<bool> AGnssRil::updateNetworkState_2_0(const V2_0::IAGnssRil::NetworkAttr
     ENTRY_LOG_CALLFLOW();
 
     if (nullptr != mGnss && (nullptr != mGnss->getGnssInterface())) {
-        int8_t typeout = loc_core::NetworkInfoDataItemBase::TYPE_UNKNOWN;
+        int8_t typeout = loc_core::TYPE_UNKNOWN;
         bool roaming = false;
         if (attributes.capabilities & IAGnssRil::NetworkCapability::NOT_METERED) {
-            typeout = loc_core::NetworkInfoDataItemBase::TYPE_WIFI;
+            typeout = loc_core::TYPE_WIFI;
         } else {
-            typeout = loc_core::NetworkInfoDataItemBase::TYPE_MOBILE;
+            typeout = loc_core::TYPE_MOBILE;
         }
         if (attributes.capabilities & IAGnssRil::NetworkCapability::NOT_ROAMING) {
             roaming = false;
diff --git a/android/2.0/Gnss.cpp b/android/2.0/Gnss.cpp
index 4fa5b63..af76b72 100644
--- a/android/2.0/Gnss.cpp
+++ b/android/2.0/Gnss.cpp
@@ -170,6 +170,23 @@ const GnssInterface* Gnss::getGnssInterface() {
 
 Return<bool> Gnss::setCallback(const sp<V1_0::IGnssCallback>& callback)  {
     ENTRY_LOG_CALLFLOW();
+
+    // In case where previous call to setCallback_1_1 or setCallback_2_0, then
+    // we need to cleanup these interfaces/callbacks here since we no longer
+    // do so in cleanup() function to keep callbacks around after cleanup()
+    if (mApi != nullptr) {
+        mApi->gnssUpdateCallbacks_2_0(nullptr);
+    }
+    if (mGnssCbIface_1_1 != nullptr) {
+        mGnssCbIface_1_1->unlinkToDeath(mGnssDeathRecipient);
+        mGnssCbIface_1_1 = nullptr;
+    }
+    if (mGnssCbIface_2_0 != nullptr) {
+        mGnssCbIface_2_0->unlinkToDeath(mGnssDeathRecipient);
+        mGnssCbIface_2_0 = nullptr;
+    }
+
+
     if (mGnssCbIface != nullptr) {
         mGnssCbIface->unlinkToDeath(mGnssDeathRecipient);
     }
@@ -291,21 +308,6 @@ Return<void> Gnss::cleanup()  {
     if (mApi != nullptr) {
         mApi->gnssStop();
         mApi->gnssDisable();
-        mApi->gnssUpdateCallbacks(nullptr, nullptr);
-        mApi->gnssUpdateCallbacks_2_0(nullptr);
-    }
-    mGnssNiCbIface = nullptr;
-    if (mGnssCbIface != nullptr) {
-        mGnssCbIface->unlinkToDeath(mGnssDeathRecipient);
-        mGnssCbIface = nullptr;
-    }
-    if (mGnssCbIface_1_1 != nullptr) {
-        mGnssCbIface_1_1->unlinkToDeath(mGnssDeathRecipient);
-        mGnssCbIface_1_1 = nullptr;
-    }
-    if (mGnssCbIface_2_0 != nullptr) {
-        mGnssCbIface_2_0->unlinkToDeath(mGnssDeathRecipient);
-        mGnssCbIface_2_0 = nullptr;
     }
 
     return Void();
@@ -417,6 +419,23 @@ Return<bool> Gnss::setCallback_1_1(const sp<V1_1::IGnssCallback>& callback) {
         LOC_LOGE("%s] Error from gnssNameCb description=%s",
                 __func__, r.description().c_str());
     }
+
+    // In case where previous call to setCallback or setCallback_2_1, then
+    // we need to cleanup these interfaces/callbacks here since we no longer
+    // do so in cleanup() function to keep callbacks around after cleanup()
+    if (mApi != nullptr) {
+        mApi->gnssUpdateCallbacks_2_0(nullptr);
+    }
+    if (mGnssCbIface != nullptr) {
+        mGnssCbIface->unlinkToDeath(mGnssDeathRecipient);
+        mGnssCbIface = nullptr;
+    }
+    if (mGnssCbIface_2_0 != nullptr) {
+        mGnssCbIface_2_0->unlinkToDeath(mGnssDeathRecipient);
+        mGnssCbIface_2_0 = nullptr;
+    }
+
+
     if (mGnssCbIface_1_1 != nullptr) {
         mGnssCbIface_1_1->unlinkToDeath(mGnssDeathRecipient);
     }
@@ -497,6 +516,7 @@ void Gnss::odcpiRequestCb(const OdcpiRequestInfo& request) {
         // For emergency mode, request DBH (Device based hybrid) location
         // Mark Independent from GNSS flag to false.
         if (ODCPI_REQUEST_TYPE_START == request.type) {
+            LOC_LOGd("gnssRequestLocationCb_2_0 isUserEmergency = %d", request.isEmergencyMode);
             auto r = mGnssCbIface_2_0->gnssRequestLocationCb_2_0(!request.isEmergencyMode,
                                                                  request.isEmergencyMode);
             if (!r.isOk()) {
@@ -529,6 +549,23 @@ Return<bool> Gnss::setCallback_2_0(const sp<V2_0::IGnssCallback>& callback) {
         LOC_LOGE("%s] Error from gnssNameCb description=%s",
                 __func__, r.description().c_str());
     }
+
+    // In case where previous call to setCallback or setCallback_1_1, then
+    // we need to cleanup these interfaces/callbacks here since we no longer
+    // do so in cleanup() function to keep callbacks around after cleanup()
+    if (mApi != nullptr) {
+        mApi->gnssUpdateCallbacks(nullptr, nullptr);
+    }
+    mGnssNiCbIface = nullptr;
+    if (mGnssCbIface != nullptr) {
+        mGnssCbIface->unlinkToDeath(mGnssDeathRecipient);
+        mGnssCbIface = nullptr;
+    }
+    if (mGnssCbIface_1_1 != nullptr) {
+        mGnssCbIface_1_1->unlinkToDeath(mGnssDeathRecipient);
+        mGnssCbIface_1_1 = nullptr;
+    }
+
     if (mGnssCbIface_2_0 != nullptr) {
         mGnssCbIface_2_0->unlinkToDeath(mGnssDeathRecipient);
     }
diff --git a/android/2.0/service.cpp b/android/2.0/service.cpp
index 16f0b06..664c661 100644
--- a/android/2.0/service.cpp
+++ b/android/2.0/service.cpp
@@ -48,7 +48,8 @@ int main() {
 
     ALOGI("%s", __FUNCTION__);
 
-    bool vendorEnhanced = isRunningWithVendorEnhancedFramework();
+    int vendorInfo = getVendorEnhancedInfo();
+    bool vendorEnhanced = ( 1 == vendorInfo || 3 == vendorInfo );
     setVendorEnhanced(vendorEnhanced);
 
 #ifdef ARCH_ARM_32
diff --git a/android/Android.mk b/android/Android.mk
index 8233b68..3b5c01f 100644
--- a/android/Android.mk
+++ b/android/Android.mk
@@ -12,6 +12,4 @@ else
 include $(DIR_LIST)/1.0/Android.mk
 endif #GNSS HIDL 1.1
 endif #GNSS HIDL 2.0
-else #QMAA flag set, build dummy android.hardware.gnss@1.0-impl-qti
-include $(LOCAL_PATH)/dummy/Android.mk
 endif #BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE
diff --git a/android/dummy/Android.mk b/android/dummy/Android.mk
deleted file mode 100644
index 05114e1..0000000
--- a/android/dummy/Android.mk
+++ /dev/null
@@ -1,54 +0,0 @@
-LOCAL_PATH := $(call my-dir)
-include $(CLEAR_VARS)
-
-#build dummy android.hardware.gnss@2.0-impl-qti
-include $(CLEAR_VARS)
-LOCAL_MODULE := android.hardware.gnss@2.0-impl-qti
-LOCAL_VENDOR_MODULE := true
-LOCAL_MODULE_RELATIVE_PATH := hw
-LOCAL_SRC_FILES := GnssDummy.cpp
-
-LOCAL_SHARED_LIBRARIES := \
-    liblog \
-    libhidlbase \
-    libhidltransport \
-    libhwbinder \
-    libcutils \
-    libutils \
-    android.hardware.gnss@1.0 \
-
-LOCAL_CFLAGS += $(GNSS_CFLAGS)
-include $(BUILD_SHARED_LIBRARY)
-
-include $(CLEAR_VARS)
-LOCAL_MODULE := android.hardware.gnss@2.0-service-qti
-LOCAL_VENDOR_MODULE := true
-LOCAL_MODULE_RELATIVE_PATH := hw
-LOCAL_INIT_RC := android.hardware.gnss@2.0-service-qti.rc
-LOCAL_SRC_FILES := \
-    serviceDummy.cpp \
-
-#LOCAL_C_INCLUDES:= \
-    $(LOCAL_PATH)/location_api
-#LOCAL_HEADER_LIBRARIES := \
-    libgps.utils_headers \
-    libloc_core_headers \
-    libloc_pla_headers \
-    liblocation_api_headers
-
-
-LOCAL_SHARED_LIBRARIES := \
-    liblog \
-    libcutils \
-    libdl \
-    libbase \
-    libutils \
-
-LOCAL_SHARED_LIBRARIES += \
-    libhwbinder \
-    libhidlbase \
-    libhidltransport \
-    android.hardware.gnss@1.0 \
-
-LOCAL_CFLAGS += $(GNSS_CFLAGS)
-include $(BUILD_EXECUTABLE)
diff --git a/android/dummy/GnssDummy.cpp b/android/dummy/GnssDummy.cpp
deleted file mode 100644
index b30b437..0000000
--- a/android/dummy/GnssDummy.cpp
+++ /dev/null
@@ -1,115 +0,0 @@
-/*
- * Copyright (c) 2017-2019, The Linux Foundation. All rights reserved.
- * Not a Contribution
- */
-/*
- * Copyright (C) 2016 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#include "GnssDummy.h"
-
-namespace android {
-namespace hardware {
-namespace gnss {
-namespace V1_0 {
-namespace implementation {
-
-Gnss::Gnss() {
-}
-
-Gnss::~Gnss() {
-}
-
-Return<bool> Gnss::setCallback(const sp<V1_0::IGnssCallback>& /*callback*/)  {
-    return false;
-}
-
-Return<bool> Gnss::start()  {
-    return false;
-}
-
-Return<bool> Gnss::stop()  {
-    return false;
-}
-
-Return<void> Gnss::cleanup()  {
-    return Void();
-}
-
-Return<bool> Gnss::injectLocation(double /*latitudeDegrees*/,
-                                  double /*longitudeDegrees*/,
-                                  float /*accuracyMeters*/)  {
-    return false;
-}
-
-Return<bool> Gnss::injectTime(int64_t /*timeMs*/, int64_t /*timeReferenceMs*/,
-                              int32_t /*uncertaintyMs*/) {
-    return false;
-}
-
-Return<void> Gnss::deleteAidingData(V1_0::IGnss::GnssAidingData /*aidingDataFlags*/)  {
-    return Void();
-}
-
-Return<bool> Gnss::setPositionMode(V1_0::IGnss::GnssPositionMode /*mode*/,
-                                   V1_0::IGnss::GnssPositionRecurrence /*recurrence*/,
-                                   uint32_t /*minIntervalMs*/,
-                                   uint32_t /*preferredAccuracyMeters*/,
-                                   uint32_t /*preferredTimeMs*/)  {
-    return false;
-}
-
-Return<sp<V1_0::IAGnss>> Gnss::getExtensionAGnss()  {
-    return nullptr;
-}
-
-Return<sp<V1_0::IGnssNi>> Gnss::getExtensionGnssNi()  {
-    return nullptr;
-}
-
-Return<sp<V1_0::IGnssMeasurement>> Gnss::getExtensionGnssMeasurement() {
-    return nullptr;
-}
-
-Return<sp<V1_0::IGnssConfiguration>> Gnss::getExtensionGnssConfiguration()  {
-    return nullptr;
-}
-
-Return<sp<V1_0::IGnssGeofencing>> Gnss::getExtensionGnssGeofencing()  {
-    return nullptr;
-}
-
-Return<sp<V1_0::IGnssBatching>> Gnss::getExtensionGnssBatching()  {
-    return nullptr;
-}
-
-Return<sp<V1_0::IGnssDebug>> Gnss::getExtensionGnssDebug() {
-    return nullptr;
-}
-
-Return<sp<V1_0::IAGnssRil>> Gnss::getExtensionAGnssRil() {
-    return nullptr;
-}
-
-IGnss* HIDL_FETCH_IGnss(const char* /*hal*/) {
-    IGnss* iface = nullptr;
-    iface = new Gnss();
-    return iface;
-}
-
-}  // namespace implementation
-}  // namespace V1_0
-}  // namespace gnss
-}  // namespace hardware
-}  // namespace android
diff --git a/android/dummy/GnssDummy.h b/android/dummy/GnssDummy.h
deleted file mode 100644
index 89c876f..0000000
--- a/android/dummy/GnssDummy.h
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
- * Copyright (c) 2017-2019, The Linux Foundation. All rights reserved.
- * Not a Contribution
- */
-/*
- * Copyright (C) 2016 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#define LOG_TAG "LocSvc_GnssInterface"
-
-#include <fstream>
-#include <dlfcn.h>
-#include <cutils/properties.h>
-
-#include <android/hardware/gnss/1.0/IGnss.h>
-#include <hidl/MQDescriptor.h>
-#include <hidl/Status.h>
-namespace android {
-namespace hardware {
-namespace gnss {
-namespace V1_0 {
-namespace implementation {
-
-using ::android::hardware::hidl_array;
-using ::android::hardware::hidl_memory;
-using ::android::hardware::hidl_string;
-using ::android::hardware::hidl_vec;
-using ::android::hardware::Return;
-using ::android::hardware::Void;
-using ::android::sp;
-using ::android::hardware::gnss::V1_0::GnssLocation;
-
-struct Gnss : public IGnss {
-    Gnss();
-    ~Gnss();
-
-    /*
-     * Methods from ::android::hardware::gnss::V1_0::IGnss follow.
-     * These declarations were generated from Gnss.hal.
-     */
-    Return<bool> setCallback(const sp<V1_0::IGnssCallback>& callback)  override;
-    Return<bool> start()  override;
-    Return<bool> stop()  override;
-    Return<void> cleanup()  override;
-    Return<bool> injectLocation(double latitudeDegrees,
-                                double longitudeDegrees,
-                                float accuracyMeters)  override;
-    Return<bool> injectTime(int64_t timeMs,
-                            int64_t timeReferenceMs,
-                            int32_t uncertaintyMs) override;
-    Return<void> deleteAidingData(V1_0::IGnss::GnssAidingData aidingDataFlags)  override;
-    Return<bool> setPositionMode(V1_0::IGnss::GnssPositionMode mode,
-                                 V1_0::IGnss::GnssPositionRecurrence recurrence,
-                                 uint32_t minIntervalMs,
-                                 uint32_t preferredAccuracyMeters,
-                                 uint32_t preferredTimeMs)  override;
-    Return<sp<V1_0::IAGnss>> getExtensionAGnss() override;
-    Return<sp<V1_0::IGnssNi>> getExtensionGnssNi() override;
-    Return<sp<V1_0::IGnssMeasurement>> getExtensionGnssMeasurement() override;
-    Return<sp<V1_0::IGnssConfiguration>> getExtensionGnssConfiguration() override;
-    Return<sp<V1_0::IGnssGeofencing>> getExtensionGnssGeofencing() override;
-    Return<sp<V1_0::IGnssBatching>> getExtensionGnssBatching() override;
-
-    Return<sp<V1_0::IAGnssRil>> getExtensionAGnssRil() override;
-
-    inline Return<sp<V1_0::IGnssNavigationMessage>> getExtensionGnssNavigationMessage() override {
-        return nullptr;
-    }
-
-    inline Return<sp<V1_0::IGnssXtra>> getExtensionXtra() override {
-        return nullptr;
-    }
-
-    Return<sp<V1_0::IGnssDebug>> getExtensionGnssDebug() override;
-};
-
-extern "C" IGnss* HIDL_FETCH_IGnss(const char* name);
-
-}  // namespace implementation
-}  // namespace V1_0
-}  // namespace gnss
-}  // namespace hardware
-}  // namespace android
-
diff --git a/android/dummy/android.hardware.gnss@2.0-service-qti.rc b/android/dummy/android.hardware.gnss@2.0-service-qti.rc
deleted file mode 100644
index 36ee47c..0000000
--- a/android/dummy/android.hardware.gnss@2.0-service-qti.rc
+++ /dev/null
@@ -1,4 +0,0 @@
-service gnss_service /vendor/bin/hw/android.hardware.gnss@2.0-service-qti
-    class hal
-    user gps
-    group system gps radio
diff --git a/android/dummy/serviceDummy.cpp b/android/dummy/serviceDummy.cpp
deleted file mode 100644
index 10ce60b..0000000
--- a/android/dummy/serviceDummy.cpp
+++ /dev/null
@@ -1,32 +0,0 @@
-/*
- * Copyright (c) 2017-2019, The Linux Foundation. All rights reserved.
- * Not a Contribution
- */
-/*
- * Copyright (C) 2016 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#define LOG_TAG "android.hardware.gnss@1.0-service-qti"
-
-#include <android/hardware/gnss/1.0/IGnss.h>
-#include <hidl/LegacySupport.h>
-
-using android::hardware::gnss::V1_0::IGnss;
-using android::hardware::defaultPassthroughServiceImplementation;
-
-int main() {
-    ALOGI("%s", __FUNCTION__);
-    return defaultPassthroughServiceImplementation<IGnss>();
-}
diff --git a/core/LocAdapterBase.cpp b/core/LocAdapterBase.cpp
index 5864fa8..ffd3d5a 100644
--- a/core/LocAdapterBase.cpp
+++ b/core/LocAdapterBase.cpp
@@ -154,7 +154,9 @@ bool LocAdapterBase::
 DEFAULT_IMPL(false)
 
 bool LocAdapterBase::
-    requestNiNotifyEvent(const GnssNiNotification &/*notify*/, const void* /*data*/)
+    requestNiNotifyEvent(const GnssNiNotification &/*notify*/,
+                         const void* /*data*/,
+                         const LocInEmergency emergencyState)
 DEFAULT_IMPL(false)
 
 void LocAdapterBase::
diff --git a/core/LocAdapterBase.h b/core/LocAdapterBase.h
index 13c8493..b9b1f1e 100644
--- a/core/LocAdapterBase.h
+++ b/core/LocAdapterBase.h
@@ -171,7 +171,8 @@ public:
     virtual bool requestATL(int connHandle, LocAGpsType agps_type,
                             LocApnTypeMask apn_type_mask);
     virtual bool releaseATL(int connHandle);
-    virtual bool requestNiNotifyEvent(const GnssNiNotification &notify, const void* data);
+    virtual bool requestNiNotifyEvent(const GnssNiNotification &notify, const void* data,
+                                      const LocInEmergency emergencyState);
     inline virtual bool isInSession() { return false; }
     ContextBase* getContext() const { return mContext; }
     virtual void reportGnssMeasurementsEvent(const GnssMeasurements& gnssMeasurements,
diff --git a/core/LocApiBase.cpp b/core/LocApiBase.cpp
index a521ceb..029f57b 100644
--- a/core/LocApiBase.cpp
+++ b/core/LocApiBase.cpp
@@ -514,10 +514,14 @@ void LocApiBase::releaseATL(int connHandle)
     TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->releaseATL(connHandle));
 }
 
-void LocApiBase::requestNiNotify(GnssNiNotification &notify, const void* data)
+void LocApiBase::requestNiNotify(GnssNiNotification &notify, const void* data,
+                                 const LocInEmergency emergencyState)
 {
     // loop through adapters, and deliver to the first handling adapter.
-    TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->requestNiNotifyEvent(notify, data));
+    TO_1ST_HANDLING_LOCADAPTERS(
+            mLocAdapters[i]->requestNiNotifyEvent(notify,
+                                                  data,
+                                                  emergencyState));
 }
 
 void* LocApiBase :: getSibling()
diff --git a/core/LocApiBase.h b/core/LocApiBase.h
index 1c2afaf..8c885f7 100644
--- a/core/LocApiBase.h
+++ b/core/LocApiBase.h
@@ -177,7 +177,8 @@ public:
     void requestLocation();
     void requestATL(int connHandle, LocAGpsType agps_type, LocApnTypeMask apn_type_mask);
     void releaseATL(int connHandle);
-    void requestNiNotify(GnssNiNotification &notify, const void* data);
+    void requestNiNotify(GnssNiNotification &notify, const void* data,
+                         const LocInEmergency emergencyState);
     void reportGnssMeasurements(GnssMeasurements& gnssMeasurements, int msInWeek);
     void reportWwanZppFix(LocGpsLocation &zppLoc);
     void reportZppBestAvailableFix(LocGpsLocation &zppLoc, GpsLocationExtended &location_extended,
diff --git a/core/SystemStatus.h b/core/SystemStatus.h
index 94f7f0b..d119a1c 100644
--- a/core/SystemStatus.h
+++ b/core/SystemStatus.h
@@ -501,19 +501,67 @@ public:
         mType = itemBase.getType();
     }
     inline bool equals(const SystemStatusNetworkInfo& peer) {
-        return (mAllTypes == peer.mAllTypes);
+        for (uint8_t i = 0; i < MAX_NETWORK_HANDLES; ++i) {
+             if (!(mAllNetworkHandles[i] == peer.mAllNetworkHandles[i])) {
+                 return false;
+             }
+         }
+        return true;
     }
     inline virtual SystemStatusItemBase& collate(SystemStatusItemBase& curInfo) {
         uint64_t allTypes = (static_cast<SystemStatusNetworkInfo&>(curInfo)).mAllTypes;
         uint64_t networkHandle =
                 (static_cast<SystemStatusNetworkInfo&>(curInfo)).mNetworkHandle;
         int32_t type = (static_cast<SystemStatusNetworkInfo&>(curInfo)).mType;
+        // Replace current with cached table for now and then update
+        memcpy(mAllNetworkHandles,
+               (static_cast<SystemStatusNetworkInfo&>(curInfo)).getNetworkHandle(),
+               sizeof(mAllNetworkHandles));
         if (mConnected) {
             mAllTypes |= allTypes;
-            mAllNetworkHandles[type] = networkHandle;
+            for (uint8_t i = 0; i < MAX_NETWORK_HANDLES; ++i) {
+                if (mNetworkHandle == mAllNetworkHandles[i].networkHandle) {
+                    LOC_LOGD("collate duplicate detected, not updating");
+                    break;
+                }
+                if (NETWORK_HANDLE_UNKNOWN == mAllNetworkHandles[i].networkHandle) {
+                    mAllNetworkHandles[i].networkHandle = mNetworkHandle;
+                    mAllNetworkHandles[i].networkType = (loc_core::NetworkType) mType;
+                    break;
+                }
+            }
         } else if (0 != mAllTypes) {
-            mAllTypes = (allTypes & (~mAllTypes));
-            mAllNetworkHandles[type] = NETWORK_HANDLE_UNKNOWN;
+            uint8_t deletedIndex = MAX_NETWORK_HANDLES;
+            uint8_t lastValidIndex = 0;
+            uint8_t typeCount = 0;
+            for (; lastValidIndex < MAX_NETWORK_HANDLES &&
+                     NETWORK_HANDLE_UNKNOWN != mAllNetworkHandles[lastValidIndex].networkHandle;
+                 ++lastValidIndex) {
+                // Maintain count for number of network handles still
+                // connected for given type
+                if (mType == mAllNetworkHandles[lastValidIndex].networkType) {
+                    typeCount++;
+                }
+
+                if (mNetworkHandle == mAllNetworkHandles[lastValidIndex].networkHandle) {
+                    deletedIndex = lastValidIndex;
+                    typeCount--;
+                }
+            }
+
+            if (MAX_NETWORK_HANDLES != deletedIndex) {
+                LOC_LOGD("deletedIndex:%u, lastValidIndex:%u, typeCount:%u",
+                        deletedIndex, lastValidIndex, typeCount);
+                mAllNetworkHandles[deletedIndex] = mAllNetworkHandles[lastValidIndex];
+                mAllNetworkHandles[lastValidIndex].networkHandle = NETWORK_HANDLE_UNKNOWN;
+                mAllNetworkHandles[lastValidIndex].networkType = TYPE_UNKNOWN;
+            }
+
+            // If no more handles of given type, set bitmask
+            if (0 == typeCount) {
+                mAllTypes = (allTypes & (~mAllTypes));
+                LOC_LOGD("mAllTypes:%" PRIx64, mAllTypes);
+            }
         } // else (mConnected == false && mAllTypes == 0)
           // we keep mAllTypes as 0, which means no more connections.
 
diff --git a/core/data-items/DataItemConcreteTypesBase.h b/core/data-items/DataItemConcreteTypesBase.h
index a6e68f1..c32d65d 100644
--- a/core/data-items/DataItemConcreteTypesBase.h
+++ b/core/data-items/DataItemConcreteTypesBase.h
@@ -32,9 +32,11 @@
 
 #include <string>
 #include <cstring>
+#include <sstream>
 #include <DataItemId.h>
 #include <IDataItemCore.h>
 #include <gps_extended_c.h>
+#include <inttypes.h>
 
 #define MAC_ADDRESS_LENGTH    6
 // MAC address length in bytes
@@ -42,10 +44,68 @@
 #define SRN_MAC_ADDRESS_LENGTH    6
 #define WIFI_SUPPLICANT_DEFAULT_STATE    0
 
+static constexpr char sDelimit = ':';
+
 namespace loc_core
 {
 using namespace std;
 
+enum NetworkType {
+    TYPE_MOBILE = 0,
+    TYPE_WIFI,
+    TYPE_ETHERNET,
+    TYPE_BLUETOOTH,
+    TYPE_MMS,
+    TYPE_SUPL,
+    TYPE_DUN,
+    TYPE_HIPRI,
+    TYPE_WIMAX,
+    TYPE_PROXY,
+    TYPE_UNKNOWN,
+};
+
+typedef struct NetworkInfoType
+{
+    // Unique network handle ID
+    uint64_t networkHandle;
+    // Type of network for corresponding network handle
+    NetworkType networkType;
+    NetworkInfoType() : networkHandle(NETWORK_HANDLE_UNKNOWN), networkType(TYPE_UNKNOWN) {}
+    NetworkInfoType(string strObj) {
+        size_t posDelimit = strObj.find(sDelimit);
+
+        if ( posDelimit != string::npos) {
+            int32_t type = TYPE_UNKNOWN;
+            string handleStr = strObj.substr(0, posDelimit);
+            string typeStr = strObj.substr(posDelimit + 1, strObj.length() - posDelimit - 1);
+            stringstream(handleStr) >> networkHandle;
+            stringstream(typeStr) >> type;
+            networkType = (NetworkType) type;
+        } else {
+            networkHandle = NETWORK_HANDLE_UNKNOWN;
+            networkType = TYPE_UNKNOWN;
+        }
+    }
+    bool operator== (const NetworkInfoType& other) {
+        return ((networkHandle == other.networkHandle) && (networkType == other.networkType));
+    }
+    string toString() {
+        string valueStr;
+        valueStr.clear ();
+        char nethandle [32];
+        memset (nethandle, 0, 32);
+        snprintf(nethandle, sizeof(nethandle), "%" PRIu64, networkHandle);
+        valueStr += string(nethandle);
+        valueStr += sDelimit;
+        char type [12];
+        memset (type, 0, 12);
+        snprintf (type, 12, "%u", networkType);
+        valueStr += string (type);
+        return valueStr;
+    }
+} NetworkInfoType;
+
+
 class AirplaneModeDataItemBase : public IDataItemCore  {
 public:
     AirplaneModeDataItemBase(bool mode):
@@ -222,19 +282,6 @@ protected:
 
 class NetworkInfoDataItemBase : public IDataItemCore {
 public:
-    enum NetworkType {
-        TYPE_MOBILE = 0,
-        TYPE_WIFI,
-        TYPE_ETHERNET,
-        TYPE_BLUETOOTH,
-        TYPE_MMS,
-        TYPE_SUPL,
-        TYPE_DUN,
-        TYPE_HIPRI,
-        TYPE_WIMAX,
-        TYPE_PROXY,
-        TYPE_UNKNOWN,
-    };
     NetworkInfoDataItemBase(
     NetworkType initialType, int32_t type, string typeName, string subTypeName,
     bool available, bool connected, bool roaming, uint64_t networkHandle ):
@@ -247,9 +294,8 @@ public:
             mRoaming(roaming),
             mNetworkHandle(networkHandle),
             mId(NETWORKINFO_DATA_ITEM_ID) {
-                memset (&mAllNetworkHandles, NETWORK_HANDLE_UNKNOWN,
-                        sizeof (mAllNetworkHandles));
-                mAllNetworkHandles[initialType] = networkHandle;
+                mAllNetworkHandles[0].networkHandle = networkHandle;
+                mAllNetworkHandles[0].networkType = initialType;
             }
     virtual ~NetworkInfoDataItemBase() {}
     inline virtual DataItemId getId() { return mId; }
@@ -259,8 +305,8 @@ public:
         return (NetworkType)mType;
     }
     inline uint64_t getAllTypes() { return mAllTypes; }
-    inline uint64_t getNetworkHandle(NetworkType type) {
-        return mAllNetworkHandles[type];
+    inline NetworkInfoType* getNetworkHandle() {
+        return &mAllNetworkHandles[0];
     }
     // Data members
     uint64_t mAllTypes;
@@ -270,7 +316,7 @@ public:
     bool mAvailable;
     bool mConnected;
     bool mRoaming;
-    uint64_t mAllNetworkHandles[TYPE_UNKNOWN + 1];
+    NetworkInfoType mAllNetworkHandles[MAX_NETWORK_HANDLES];
     uint64_t mNetworkHandle;
 protected:
     DataItemId mId;
diff --git a/gnss/GnssAdapter.cpp b/gnss/GnssAdapter.cpp
index 532c6b6..026c1ee 100644
--- a/gnss/GnssAdapter.cpp
+++ b/gnss/GnssAdapter.cpp
@@ -97,8 +97,7 @@ GnssAdapter::GnssAdapter() :
     mPowerStateCb(nullptr),
     mIsE911Session(NULL),
     mGnssMbSvIdUsedInPosition{},
-    mGnssMbSvIdUsedInPosAvail(false),
-    mGnssSignalType()
+    mGnssMbSvIdUsedInPosAvail(false)
 {
     LOC_LOGD("%s]: Constructor %p", __func__, this);
     mLocPositionMode.mode = LOC_POSITION_MODE_INVALID;
@@ -475,6 +474,16 @@ GnssAdapter::convertLocationInfo(GnssLocationInfoNotification& out,
         out.flags |= GNSS_LOCATION_INFO_TIME_UNC_BIT;
         out.timeUncMs = locationExtended.timeUncMs;
     }
+
+    if (GPS_LOCATION_EXTENDED_HAS_CALIBRATION_CONFIDENCE & locationExtended.flags) {
+        out.flags |= GNSS_LOCATION_INFO_CALIBRATION_CONFIDENCE_BIT;
+        out.calibrationConfidence = locationExtended.calibrationConfidence;
+    }
+
+    if (GPS_LOCATION_EXTENDED_HAS_CALIBRATION_STATUS & locationExtended.flags) {
+        out.flags |= GNSS_LOCATION_INFO_CALIBRATION_STATUS_BIT;
+        out.calibrationStatus = locationExtended.calibrationStatus;
+    }
 }
 
 
@@ -659,7 +668,7 @@ GnssAdapter::setSuplHostServer(const char* server, int port, LocServerType type)
             LOC_LOGe("Invalid type=%d", type);
         } else {
             string& url = (LOC_AGPS_SUPL_SERVER == type) ? getServerUrl() : getMoServerUrl();
-            if (length > 0 && strncasecmp(url.c_str(), serverUrl, sizeof(serverUrl)) != 0) {
+            if (length >= 0 && strncasecmp(url.c_str(), serverUrl, sizeof(serverUrl)) != 0) {
                 url.assign(serverUrl);
 
                 if (LOC_AGPS_SUPL_SERVER == type) {
@@ -837,7 +846,7 @@ std::vector<LocationError> GnssAdapter::gnssUpdateConfig(const std::string& oldS
                 GNSS_CONFIG_FLAGS_SET_ASSISTANCE_DATA_VALID_BIT) {
             if (gnssConfigNeedEngineUpdate.assistanceServer.type ==
                     GNSS_ASSISTANCE_TYPE_SUPL) {
-                if ((serverUrlLen != 0) && (oldServerUrl.compare(serverUrl) !=0)) {
+                if (0 != oldServerUrl.compare(serverUrl)) {
 
                     err = mLocApi->setServerSync(
                             serverUrl.c_str(), serverUrlLen, LOC_AGPS_SUPL_SERVER);
@@ -845,7 +854,7 @@ std::vector<LocationError> GnssAdapter::gnssUpdateConfig(const std::string& oldS
                         errsList[index] = err;
                     }
                 }
-                if ((moServerUrlLen != 0) && (oldMoServerUrl.compare(moServerUrl) != 0)) {
+                if (0 != oldMoServerUrl.compare(moServerUrl)) {
                     LocationError locErr =
                         mLocApi->setServerSync(moServerUrl.c_str(),
                                 moServerUrlLen,
@@ -1080,12 +1089,7 @@ GnssAdapter::gnssUpdateConfigCommand(GnssConfig config)
             if (gnssConfigRequested.flags & GNSS_CONFIG_FLAGS_SUPL_VERSION_VALID_BIT) {
                 uint32_t newSuplVersion =
                         mAdapter.convertSuplVersion(gnssConfigRequested.suplVersion);
-                if (newSuplVersion != ContextBase::mGps_conf.SUPL_VER &&
-                    ContextBase::mGps_conf.AGPS_CONFIG_INJECT) {
-                    ContextBase::mGps_conf.SUPL_VER = newSuplVersion;
-                } else {
-                    gnssConfigNeedEngineUpdate.flags &= ~(GNSS_CONFIG_FLAGS_SUPL_VERSION_VALID_BIT);
-                }
+                ContextBase::mGps_conf.SUPL_VER = newSuplVersion;
                 index++;
             }
             if (gnssConfigRequested.flags & GNSS_CONFIG_FLAGS_SET_ASSISTANCE_DATA_VALID_BIT) {
@@ -1104,47 +1108,26 @@ GnssAdapter::gnssUpdateConfigCommand(GnssConfig config)
             }
             if (gnssConfigRequested.flags & GNSS_CONFIG_FLAGS_LPP_PROFILE_VALID_BIT) {
                 uint32_t newLppProfile = mAdapter.convertLppProfile(gnssConfigRequested.lppProfile);
-                if (newLppProfile != ContextBase::mGps_conf.LPP_PROFILE &&
-                    ContextBase::mGps_conf.AGPS_CONFIG_INJECT) {
-                    ContextBase::mGps_conf.LPP_PROFILE = newLppProfile;
-                } else {
-                    gnssConfigNeedEngineUpdate.flags &= ~(GNSS_CONFIG_FLAGS_LPP_PROFILE_VALID_BIT);
-                }
+                ContextBase::mGps_conf.LPP_PROFILE = newLppProfile;
                 index++;
             }
             if (gnssConfigRequested.flags & GNSS_CONFIG_FLAGS_LPPE_CONTROL_PLANE_VALID_BIT) {
                 uint32_t newLppeControlPlaneMask =
-                    mAdapter.convertLppeCp(gnssConfigRequested.lppeControlPlaneMask);
-                if (newLppeControlPlaneMask != ContextBase::mGps_conf.LPPE_CP_TECHNOLOGY) {
-                    ContextBase::mGps_conf.LPPE_CP_TECHNOLOGY = newLppeControlPlaneMask;
-                } else {
-                    gnssConfigNeedEngineUpdate.flags &=
-                            ~(GNSS_CONFIG_FLAGS_LPPE_CONTROL_PLANE_VALID_BIT);
-                }
+                        mAdapter.convertLppeCp(gnssConfigRequested.lppeControlPlaneMask);
+                ContextBase::mGps_conf.LPPE_CP_TECHNOLOGY = newLppeControlPlaneMask;
                 index++;
             }
             if (gnssConfigRequested.flags & GNSS_CONFIG_FLAGS_LPPE_USER_PLANE_VALID_BIT) {
                 uint32_t newLppeUserPlaneMask =
-                    mAdapter.convertLppeUp(gnssConfigRequested.lppeUserPlaneMask);
-                if (newLppeUserPlaneMask != ContextBase::mGps_conf.LPPE_UP_TECHNOLOGY) {
-                    ContextBase::mGps_conf.LPPE_UP_TECHNOLOGY = newLppeUserPlaneMask;
-                } else {
-                    gnssConfigNeedEngineUpdate.flags &=
-                            ~(GNSS_CONFIG_FLAGS_LPPE_USER_PLANE_VALID_BIT);
-                }
+                        mAdapter.convertLppeUp(gnssConfigRequested.lppeUserPlaneMask);
+                ContextBase::mGps_conf.LPPE_UP_TECHNOLOGY = newLppeUserPlaneMask;
                 index++;
             }
             if (gnssConfigRequested.flags &
                     GNSS_CONFIG_FLAGS_AGLONASS_POSITION_PROTOCOL_VALID_BIT) {
                 uint32_t newAGloProtMask =
-                    mAdapter.convertAGloProt(gnssConfigRequested.aGlonassPositionProtocolMask);
-                if (newAGloProtMask != ContextBase::mGps_conf.A_GLONASS_POS_PROTOCOL_SELECT &&
-                    ContextBase::mGps_conf.AGPS_CONFIG_INJECT) {
-                    ContextBase::mGps_conf.A_GLONASS_POS_PROTOCOL_SELECT = newAGloProtMask;
-                } else {
-                    gnssConfigNeedEngineUpdate.flags &=
-                            ~(GNSS_CONFIG_FLAGS_AGLONASS_POSITION_PROTOCOL_VALID_BIT);
-                }
+                        mAdapter.convertAGloProt(gnssConfigRequested.aGlonassPositionProtocolMask);
+                ContextBase::mGps_conf.A_GLONASS_POS_PROTOCOL_SELECT = newAGloProtMask;
                 index++;
             }
             if (gnssConfigRequested.flags & GNSS_CONFIG_FLAGS_EM_PDN_FOR_EM_SUPL_VALID_BIT) {
@@ -1165,10 +1148,8 @@ GnssAdapter::gnssUpdateConfigCommand(GnssConfig config)
             }
             if (gnssConfigRequested.flags & GNSS_CONFIG_FLAGS_SUPL_MODE_BIT) {
                 uint32_t newSuplMode = mAdapter.convertSuplMode(gnssConfigRequested.suplModeMask);
-                if (newSuplMode != ContextBase::mGps_conf.SUPL_MODE) {
-                    ContextBase::mGps_conf.SUPL_MODE = newSuplMode;
-                    mAdapter.broadcastCapabilities(mAdapter.getCapabilities());
-                }
+                ContextBase::mGps_conf.SUPL_MODE = newSuplMode;
+                mAdapter.broadcastCapabilities(mAdapter.getCapabilities());
                 index++;
             }
 
@@ -3197,9 +3178,6 @@ GnssAdapter::reportPosition(const UlpLocation& ulpLocation,
                 if (locationExtended.flags & GPS_LOCATION_EXTENDED_HAS_MULTIBAND) {
                     mGnssMbSvIdUsedInPosAvail = true;
                     mGnssMbSvIdUsedInPosition = locationExtended.gnss_mb_sv_used_ids;
-                    for (int i = 0; i < GNSS_SV_MAX; i++) {
-                        mGnssSignalType[i] = locationExtended.measUsageInfo[i].gnssSignalType;
-                    }
                 }
             }
 
@@ -3268,11 +3246,12 @@ GnssAdapter::reportSv(GnssSvNotification& svNotify)
     for (int i=0; i < numSv; i++) {
         svUsedIdMask = 0;
         gnssSvId = svNotify.gnssSvs[i].svId;
+        GnssSignalTypeMask signalTypeMask = svNotify.gnssSvs[i].gnssSignalTypeMask;
         switch (svNotify.gnssSvs[i].type) {
             case GNSS_SV_TYPE_GPS:
                 if (mGnssSvIdUsedInPosAvail) {
                     if (mGnssMbSvIdUsedInPosAvail) {
-                        switch (mGnssSignalType[i]) {
+                        switch (signalTypeMask) {
                         case GNSS_SIGNAL_GPS_L1CA:
                             svUsedIdMask = mGnssMbSvIdUsedInPosition.gps_l1ca_sv_used_ids_mask;
                             break;
@@ -3294,7 +3273,7 @@ GnssAdapter::reportSv(GnssSvNotification& svNotify)
             case GNSS_SV_TYPE_GLONASS:
                 if (mGnssSvIdUsedInPosAvail) {
                     if (mGnssMbSvIdUsedInPosAvail) {
-                        switch (mGnssSignalType[i]) {
+                        switch (signalTypeMask) {
                         case GNSS_SIGNAL_GLONASS_G1:
                             svUsedIdMask = mGnssMbSvIdUsedInPosition.glo_g1_sv_used_ids_mask;
                             break;
@@ -3310,7 +3289,7 @@ GnssAdapter::reportSv(GnssSvNotification& svNotify)
             case GNSS_SV_TYPE_BEIDOU:
                 if (mGnssSvIdUsedInPosAvail) {
                     if (mGnssMbSvIdUsedInPosAvail) {
-                        switch (mGnssSignalType[i]) {
+                        switch (signalTypeMask) {
                         case GNSS_SIGNAL_BEIDOU_B1I:
                             svUsedIdMask = mGnssMbSvIdUsedInPosition.bds_b1i_sv_used_ids_mask;
                             break;
@@ -3323,6 +3302,9 @@ GnssAdapter::reportSv(GnssSvNotification& svNotify)
                         case GNSS_SIGNAL_BEIDOU_B2AI:
                             svUsedIdMask = mGnssMbSvIdUsedInPosition.bds_b2ai_sv_used_ids_mask;
                             break;
+                        case GNSS_SIGNAL_BEIDOU_B2AQ:
+                            svUsedIdMask = mGnssMbSvIdUsedInPosition.bds_b2aq_sv_used_ids_mask;
+                            break;
                         }
                     } else {
                         svUsedIdMask = mGnssSvIdUsedInPosition.bds_sv_used_ids_mask;
@@ -3332,7 +3314,7 @@ GnssAdapter::reportSv(GnssSvNotification& svNotify)
             case GNSS_SV_TYPE_GALILEO:
                 if (mGnssSvIdUsedInPosAvail) {
                     if (mGnssMbSvIdUsedInPosAvail) {
-                        switch (mGnssSignalType[i]) {
+                        switch (signalTypeMask) {
                         case GNSS_SIGNAL_GALILEO_E1:
                             svUsedIdMask = mGnssMbSvIdUsedInPosition.gal_e1_sv_used_ids_mask;
                             break;
@@ -3351,7 +3333,7 @@ GnssAdapter::reportSv(GnssSvNotification& svNotify)
             case GNSS_SV_TYPE_QZSS:
                 if (mGnssSvIdUsedInPosAvail) {
                     if (mGnssMbSvIdUsedInPosAvail) {
-                        switch (mGnssSignalType[i]) {
+                        switch (signalTypeMask) {
                         case GNSS_SIGNAL_QZSS_L1CA:
                             svUsedIdMask = mGnssMbSvIdUsedInPosition.qzss_l1ca_sv_used_ids_mask;
                             break;
@@ -3527,7 +3509,8 @@ GnssAdapter::reportData(GnssDataNotification& dataNotify)
 }
 
 bool
-GnssAdapter::requestNiNotifyEvent(const GnssNiNotification &notify, const void* data)
+GnssAdapter::requestNiNotifyEvent(const GnssNiNotification &notify, const void* data,
+                                  const LocInEmergency emergencyState)
 {
     LOC_LOGI("%s]: notif_type: %d, timeout: %d, default_resp: %d"
              "requestor_id: %s (encoding: %d) text: %s text (encoding: %d) extras: %s",
@@ -3540,37 +3523,49 @@ GnssAdapter::requestNiNotifyEvent(const GnssNiNotification &notify, const void*
         LocApiBase& mApi;
         const GnssNiNotification mNotify;
         const void* mData;
+        const LocInEmergency mEmergencyState;
         inline MsgReportNiNotify(GnssAdapter& adapter,
                                  LocApiBase& api,
                                  const GnssNiNotification& notify,
-                                 const void* data) :
+                                 const void* data,
+                                 const LocInEmergency emergencyState) :
             LocMsg(),
             mAdapter(adapter),
             mApi(api),
             mNotify(notify),
-            mData(data) {}
+            mData(data),
+            mEmergencyState(emergencyState) {}
         inline virtual void proc() const {
+            bool bIsInEmergency = false;
+            bool bInformNiAccept = false;
+
+            bIsInEmergency = ((LOC_IN_EMERGENCY_UNKNOWN == mEmergencyState) &&
+                    mAdapter.getE911State()) ||                // older modems
+                    (LOC_IN_EMERGENCY_SET == mEmergencyState); // newer modems
+
             if (GNSS_NI_TYPE_EMERGENCY_SUPL == mNotify.type) {
-                if (mAdapter.getE911State() ||
-                    (GNSS_CONFIG_SUPL_EMERGENCY_SERVICES_NO == ContextBase::mGps_conf.SUPL_ES)) {
-                    mApi.informNiResponse(GNSS_NI_RESPONSE_ACCEPT, mData);
+                bInformNiAccept = bIsInEmergency ||
+                        (GNSS_CONFIG_SUPL_EMERGENCY_SERVICES_NO == ContextBase::mGps_conf.SUPL_ES);
+
+                if (bInformNiAccept) {
+                    mAdapter.requestNiNotify(mNotify, mData, bInformNiAccept);
                 } else {
                     mApi.informNiResponse(GNSS_NI_RESPONSE_DENY, mData);
                 }
             } else if (GNSS_NI_TYPE_CONTROL_PLANE == mNotify.type) {
-                if (mAdapter.getE911State() &&
-                    (1 == ContextBase::mGps_conf.CP_MTLR_ES)) {
+                if (bIsInEmergency && (1 == ContextBase::mGps_conf.CP_MTLR_ES)) {
                     mApi.informNiResponse(GNSS_NI_RESPONSE_ACCEPT, mData);
-                } else {
-                    mAdapter.requestNiNotify(mNotify, mData);
+                }
+                else {
+                    mAdapter.requestNiNotify(mNotify, mData, false);
                 }
             } else {
-                mAdapter.requestNiNotify(mNotify, mData);
+                mAdapter.requestNiNotify(mNotify, mData, false);
             }
         }
     };
 
-    sendMsg(new MsgReportNiNotify(*this, *mLocApi, notify, data));
+    sendMsg(new MsgReportNiNotify(*this, *mLocApi, notify, data, emergencyState));
 
     return true;
 }
@@ -3693,7 +3688,8 @@ static void* niThreadProc(void *args)
 }
 
 bool
-GnssAdapter::requestNiNotify(const GnssNiNotification& notify, const void* data)
+GnssAdapter::requestNiNotify(const GnssNiNotification& notify, const void* data,
+                             const bool bInformNiAccept)
 {
     NiSession* pSession = NULL;
     gnssNiCallback gnssNiCb = nullptr;
@@ -3705,6 +3701,20 @@ GnssAdapter::requestNiNotify(const GnssNiNotification& notify, const void* data)
         }
     }
     if (nullptr == gnssNiCb) {
+        if (GNSS_NI_TYPE_EMERGENCY_SUPL == notify.type) {
+            if (bInformNiAccept) {
+                mLocApi->informNiResponse(GNSS_NI_RESPONSE_ACCEPT, data);
+                NiData& niData = getNiData();
+                // ignore any SUPL NI non-Es session if a SUPL NI ES is accepted
+                if (NULL != niData.session.rawRequest) {
+                    pthread_mutex_lock(&niData.session.tLock);
+                    niData.session.resp = GNSS_NI_RESPONSE_IGNORE;
+                    niData.session.respRecvd = true;
+                    pthread_cond_signal(&niData.session.tCond);
+                    pthread_mutex_unlock(&niData.session.tLock);
+                }
+            }
+        }
         EXIT_LOG(%s, "no clients with gnssNiCb.");
         return false;
     }
@@ -3770,26 +3780,28 @@ GnssAdapter::reportGnssMeasurementsEvent(const GnssMeasurements& gnssMeasurement
 {
     LOC_LOGD("%s]: msInWeek=%d", __func__, msInWeek);
 
-    struct MsgReportGnssMeasurementData : public LocMsg {
-        GnssAdapter& mAdapter;
-        GnssMeasurements mGnssMeasurements;
-        GnssMeasurementsNotification mMeasurementsNotify;
-        inline MsgReportGnssMeasurementData(GnssAdapter& adapter,
-                                            const GnssMeasurements& gnssMeasurements,
-                                            int msInWeek) :
-                LocMsg(),
-                mAdapter(adapter),
-                mMeasurementsNotify(gnssMeasurements.gnssMeasNotification) {
-            if (-1 != msInWeek) {
-                mAdapter.getAgcInformation(mMeasurementsNotify, msInWeek);
+    if (0 != gnssMeasurements.gnssMeasNotification.count) {
+        struct MsgReportGnssMeasurementData : public LocMsg {
+            GnssAdapter& mAdapter;
+            GnssMeasurements mGnssMeasurements;
+            GnssMeasurementsNotification mMeasurementsNotify;
+            inline MsgReportGnssMeasurementData(GnssAdapter& adapter,
+                                                const GnssMeasurements& gnssMeasurements,
+                                                int msInWeek) :
+                    LocMsg(),
+                    mAdapter(adapter),
+                    mMeasurementsNotify(gnssMeasurements.gnssMeasNotification) {
+                if (-1 != msInWeek) {
+                    mAdapter.getAgcInformation(mMeasurementsNotify, msInWeek);
+                }
             }
-        }
-        inline virtual void proc() const {
-            mAdapter.reportGnssMeasurementData(mMeasurementsNotify);
-        }
-    };
+            inline virtual void proc() const {
+                mAdapter.reportGnssMeasurementData(mMeasurementsNotify);
+            }
+        };
 
-    sendMsg(new MsgReportGnssMeasurementData(*this, gnssMeasurements, msInWeek));
+        sendMsg(new MsgReportGnssMeasurementData(*this, gnssMeasurements, msInWeek));
+    }
     mEngHubProxy->gnssReportSvMeasurement(gnssMeasurements.gnssSvMeasurementSet);
 }
 
diff --git a/gnss/GnssAdapter.h b/gnss/GnssAdapter.h
index 1e6d1b8..a44e68c 100644
--- a/gnss/GnssAdapter.h
+++ b/gnss/GnssAdapter.h
@@ -147,7 +147,6 @@ class GnssAdapter : public LocAdapterBase {
     bool mGnssSvIdUsedInPosAvail;
     GnssSvMbUsedInPosition mGnssMbSvIdUsedInPosition;
     bool mGnssMbSvIdUsedInPosAvail;
-    GnssSignalTypeMask mGnssSignalType[GNSS_SV_MAX];
 
     /* ==== CONTROL ======================================================================== */
     LocationControlCallbacks mControlCallbacks;
@@ -360,7 +359,8 @@ public:
                                bool fromEngineHub=false);
     virtual void reportNmeaEvent(const char* nmea, size_t length);
     virtual void reportDataEvent(const GnssDataNotification& dataNotify, int msInWeek);
-    virtual bool requestNiNotifyEvent(const GnssNiNotification& notify, const void* data);
+    virtual bool requestNiNotifyEvent(const GnssNiNotification& notify, const void* data,
+                                      const LocInEmergency emergencyState);
     virtual void reportGnssMeasurementsEvent(const GnssMeasurements& gnssMeasurements,
                                                 int msInWeek);
     virtual void reportSvPolynomialEvent(GnssSvPolynomial &svPolynomial);
@@ -390,7 +390,8 @@ public:
     void reportSv(GnssSvNotification& svNotify);
     void reportNmea(const char* nmea, size_t length);
     void reportData(GnssDataNotification& dataNotify);
-    bool requestNiNotify(const GnssNiNotification& notify, const void* data);
+    bool requestNiNotify(const GnssNiNotification& notify, const void* data,
+                         const bool bInformNiAccept);
     void reportGnssMeasurementData(const GnssMeasurementsNotification& measurements);
     void reportGnssSvIdConfig(const GnssSvIdConfig& config);
     void reportGnssSvTypeConfig(const GnssSvTypeConfig& config);
diff --git a/gnss/XtraSystemStatusObserver.cpp b/gnss/XtraSystemStatusObserver.cpp
index af593fb..1671c76 100644
--- a/gnss/XtraSystemStatusObserver.cpp
+++ b/gnss/XtraSystemStatusObserver.cpp
@@ -129,19 +129,33 @@ bool XtraSystemStatusObserver::updateLockStatus(GnssConfigGpsLock lock) {
 }
 
 bool XtraSystemStatusObserver::updateConnections(uint64_t allConnections,
-        uint64_t wifiNetworkHandle, uint64_t mobileNetworkHandle) {
+        NetworkInfoType* networkHandleInfo) {
     mIsConnectivityStatusKnown = true;
     mConnections = allConnections;
-    mWifiNetworkHandle = wifiNetworkHandle;
-    mMobileNetworkHandle = mobileNetworkHandle;
+
+    LOC_LOGd("updateConnections mConnections:%" PRIx64, mConnections);
+    for (uint8_t i = 0; i < MAX_NETWORK_HANDLES; ++i) {
+        mNetworkHandle[i] = networkHandleInfo[i];
+        LOC_LOGd("updateConnections [%d] networkHandle:%" PRIx64 " networkType:%u",
+            i, mNetworkHandle[i].networkHandle, mNetworkHandle[i].networkType);
+    }
 
     if (!mReqStatusReceived) {
         return true;
     }
 
     stringstream ss;
-    ss << "connection" << endl << mConnections << endl << wifiNetworkHandle
-            << endl << mobileNetworkHandle;
+    ss << "connection" << endl << mConnections << endl
+            << mNetworkHandle[0].toString() << endl
+            << mNetworkHandle[1].toString() << endl
+            << mNetworkHandle[2].toString() << endl
+            << mNetworkHandle[3].toString() << endl
+            << mNetworkHandle[4].toString() << endl
+            << mNetworkHandle[5].toString() << endl
+            << mNetworkHandle[6].toString() << endl
+            << mNetworkHandle[7].toString() << endl
+            << mNetworkHandle[8].toString() << endl
+            << mNetworkHandle[MAX_NETWORK_HANDLES-1].toString();
     string s = ss.str();
     return ( LocIpc::send(*mSender, (const uint8_t*)s.data(), s.size()) );
 }
@@ -200,7 +214,16 @@ inline bool XtraSystemStatusObserver::onStatusRequested(int32_t xtraStatusUpdate
     ss << "respondStatus" << endl;
     (mGpsLock == -1 ? ss : ss << mGpsLock) << endl;
     (mConnections == (uint64_t)~0 ? ss : ss << mConnections) << endl
-            << mWifiNetworkHandle << endl << mMobileNetworkHandle << endl
+            << mNetworkHandle[0].toString() << endl
+            << mNetworkHandle[1].toString() << endl
+            << mNetworkHandle[2].toString() << endl
+            << mNetworkHandle[3].toString() << endl
+            << mNetworkHandle[4].toString() << endl
+            << mNetworkHandle[5].toString() << endl
+            << mNetworkHandle[6].toString() << endl
+            << mNetworkHandle[7].toString() << endl
+            << mNetworkHandle[8].toString() << endl
+            << mNetworkHandle[MAX_NETWORK_HANDLES-1].toString() << endl
             << mTac << endl << mMccmnc << endl << mIsConnectivityStatusKnown;
 
     string s = ss.str();
@@ -272,11 +295,10 @@ void XtraSystemStatusObserver::notify(const list<IDataItemCore*>& dlist)
                     {
                         NetworkInfoDataItemBase* networkInfo =
                                 static_cast<NetworkInfoDataItemBase*>(each);
+                        NetworkInfoType* networkHandleInfo =
+                                static_cast<NetworkInfoType*>(networkInfo->getNetworkHandle());
                         mXtraSysStatObj->updateConnections(networkInfo->getAllTypes(),
-                                (NetworkHandle) networkInfo->getNetworkHandle(
-                                        loc_core::NetworkInfoDataItemBase::TYPE_WIFI),
-                                (NetworkHandle) networkInfo->getNetworkHandle(
-                                        loc_core::NetworkInfoDataItemBase::TYPE_MOBILE));
+                                networkHandleInfo);
                     }
                     break;
 
diff --git a/gnss/XtraSystemStatusObserver.h b/gnss/XtraSystemStatusObserver.h
index 14f9393..3a5259d 100644
--- a/gnss/XtraSystemStatusObserver.h
+++ b/gnss/XtraSystemStatusObserver.h
@@ -55,7 +55,7 @@ public :
 
     bool updateLockStatus(GnssConfigGpsLock lock);
     bool updateConnections(uint64_t allConnections,
-            uint64_t wifiNetworkHandle, uint64_t mobileNetworkHandle);
+            loc_core::NetworkInfoType* networkHandleInfo);
     bool updateTac(const string& tac);
     bool updateMccMnc(const string& mccmnc);
     bool updateXtraThrottle(const bool enabled);
@@ -69,8 +69,7 @@ private:
     GnssConfigGpsLock mGpsLock;
     LocIpc mIpc;
     uint64_t mConnections;
-    uint64_t mWifiNetworkHandle;
-    uint64_t mMobileNetworkHandle;
+    loc_core::NetworkInfoType mNetworkHandle[MAX_NETWORK_HANDLES];
     string mTac;
     string mMccmnc;
     bool mXtraThrottle;
diff --git a/gps_vendor_board.mk b/gps_vendor_board.mk
index be346dc..e1915ea 100644
--- a/gps_vendor_board.mk
+++ b/gps_vendor_board.mk
@@ -1,3 +1,7 @@
 # Flags from BoardConfigVendor.mk
+ifneq ($(TARGET_USES_QMAA),true)
 BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE := default
+else ifneq ($(TARGET_USES_QMAA_OVERRIDE_GPS),false)
+BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE := default
+endif
 
diff --git a/location/LocationDataTypes.h b/location/LocationDataTypes.h
index d6abda2..49822fa 100644
--- a/location/LocationDataTypes.h
+++ b/location/LocationDataTypes.h
@@ -172,8 +172,9 @@ typedef enum {
     GNSS_LOCATION_INFO_UP_VEL_UNC_BIT                   = (1<<21),// valid Up Velocity Uncertainty
     GNSS_LOCATION_INFO_LEAP_SECONDS_BIT                 = (1<<22),// valid leap seconds
     GNSS_LOCATION_INFO_TIME_UNC_BIT                     = (1<<23),// valid time uncertainty
-    GNSS_LOCATION_INFO_NUM_SV_USED_IN_POSITION_BIT      = (1<<24) // number of SV used in position
-
+    GNSS_LOCATION_INFO_NUM_SV_USED_IN_POSITION_BIT      = (1<<24), // number of SV used in position
+    GNSS_LOCATION_INFO_CALIBRATION_CONFIDENCE_BIT       = (1<<25), // valid sensor cal confidence
+    GNSS_LOCATION_INFO_CALIBRATION_STATUS_BIT           = (1<<26), // valid sensor cal status
 } GnssLocationInfoFlagBits;
 
 typedef enum {
@@ -583,7 +584,9 @@ typedef enum {
     /** SBAS L1 RF Band */
     GNSS_SIGNAL_SBAS_L1             = (1<<17),
     /** NAVIC L5 RF Band */
-    GNSS_SIGNAL_NAVIC_L5            = (1<<18)
+    GNSS_SIGNAL_NAVIC_L5            = (1<<18),
+    /** BEIDOU B2A_Q RF Band */
+    GNSS_SIGNAL_BEIDOU_B2AQ         = (1<<19)
 } GnssSignalTypeBits;
 
 #define GNSS_SIGNAL_TYPE_MASK_ALL\
@@ -593,12 +596,14 @@ typedef enum {
      GNSS_SIGNAL_BEIDOU_B1I | GNSS_SIGNAL_BEIDOU_B1C | GNSS_SIGNAL_BEIDOU_B2I|\
      GNSS_SIGNAL_BEIDOU_B2AI | GNSS_SIGNAL_QZSS_L1CA | GNSS_SIGNAL_QZSS_L1S |\
      GNSS_SIGNAL_QZSS_L2| GNSS_SIGNAL_QZSS_L5 | GNSS_SIGNAL_SBAS_L1 |\
-     GNSS_SIGNAL_NAVIC_L5)
+     GNSS_SIGNAL_NAVIC_L5 | GNSS_SIGNAL_BEIDOU_B2AQ)
 
 typedef enum
 {
     GNSS_LOC_SV_SYSTEM_UNKNOWN                = 0,
     /** unknown sv system. */
+    GNSS_LOC_SV_SYSTEM_MIN                    = 1,
+    /**< Min enum of valid SV system. */
     GNSS_LOC_SV_SYSTEM_GPS                    = 1,
     /**< GPS satellite. */
     GNSS_LOC_SV_SYSTEM_GALILEO                = 2,
@@ -611,8 +616,10 @@ typedef enum
     /**< BDS satellite. */
     GNSS_LOC_SV_SYSTEM_QZSS                   = 6,
     /**< QZSS satellite. */
-    GNSS_LOC_SV_SYSTEM_NAVIC                  = 7
+    GNSS_LOC_SV_SYSTEM_NAVIC                  = 7,
     /**< QZSS satellite. */
+    GNSS_LOC_SV_SYSTEM_MAX                    = 7,
+    /**< Max enum of valid SV system. */
 } Gnss_LocSvSystemEnumType;
 
 typedef enum {
@@ -635,7 +642,8 @@ typedef enum {
     GNSS_LOC_SIGNAL_TYPE_QZSS_L5_Q = 16,        /**<  QZSS L5_Q RF Band  */
     GNSS_LOC_SIGNAL_TYPE_SBAS_L1_CA = 17,       /**<  SBAS L1_CA RF Band  */
     GNSS_LOC_SIGNAL_TYPE_NAVIC_L5 = 18,         /**<  NAVIC L5 RF Band */
-    GNSS_LOC_MAX_NUMBER_OF_SIGNAL_TYPES = 19    /**<  Maximum number of signal types */
+    GNSS_LOC_SIGNAL_TYPE_BEIDOU_B2A_Q = 19,     /**<  BEIDOU B2A_Q RF Band  */
+    GNSS_LOC_MAX_NUMBER_OF_SIGNAL_TYPES = 20    /**<  Maximum number of signal types */
 } Gnss_LocSignalEnumType;
 
 typedef uint64_t GnssDataMask;
@@ -692,6 +700,20 @@ typedef struct {
     GnssAidingDataCommon common; // common aiding data
 } GnssAidingData;
 
+typedef uint16_t DrCalibrationStatusMask;
+typedef enum {
+    // Indicate that roll calibration is needed. Need to take more turns on level ground
+    DR_ROLL_CALIBRATION_NEEDED  = (1<<0),
+    // Indicate that pitch calibration is needed. Need to take more turns on level ground
+    DR_PITCH_CALIBRATION_NEEDED = (1<<1),
+    // Indicate that yaw calibration is needed. Need to accelerate in a straight line
+    DR_YAW_CALIBRATION_NEEDED   = (1<<2),
+    // Indicate that odo calibration is needed. Need to accelerate in a straight line
+    DR_ODO_CALIBRATION_NEEDED   = (1<<3),
+    // Indicate that gyro calibration is needed. Need to take more turns on level ground
+    DR_GYRO_CALIBRATION_NEEDED  = (1<<4)
+} DrCalibrationStatusBits;
+
 typedef struct {
     uint32_t size;           // set to sizeof(Location)
     LocationFlagsMask flags; // bitwise OR of LocationFlagsBits to mark which params are valid
@@ -938,7 +960,8 @@ typedef struct {
 } GnssSystemTime;
 
 typedef struct {
-    uint32_t size;                        // set to sizeof(GnssLocationInfo)
+    uint32_t size;                      // set to sizeof(GnssLocationInfo)
+    Location location;                  // basic locaiton info, latitude, longitude, and etc
     GnssLocationInfoFlagMask flags;     // bitwise OR of GnssLocationInfoBits for param validity
     float altitudeMeanSeaLevel;         // altitude wrt mean sea level
     float pdop;                         // position dilusion of precision
@@ -971,7 +994,9 @@ typedef struct {
     GnssMeasUsageInfo measUsageInfo[GNSS_SV_MAX]; // GNSS Measurement Usage info
     uint8_t leapSeconds;                          // leap second
     float timeUncMs;                              // Time uncertainty in milliseconds
-    Location location;
+    uint8_t calibrationConfidence;                // Sensor calibration confidence percent,
+                                                  // in range of [0, 100]
+    DrCalibrationStatusMask calibrationStatus;    // Sensor calibration status
 } GnssLocationInfoNotification;
 
 typedef struct {
diff --git a/utils/LocIpc.cpp b/utils/LocIpc.cpp
index 646d2d4..f4dd0b4 100644
--- a/utils/LocIpc.cpp
+++ b/utils/LocIpc.cpp
@@ -164,7 +164,8 @@ public:
 
         umask(0157);
         if (mSock->isValid() && ::bind(mSock->mSid, (struct sockaddr*)&mAddr, sizeof(mAddr)) < 0) {
-            LOC_LOGe("bind socket error. sock fd: %d, reason: %s", mSock->mSid, strerror(errno));
+            LOC_LOGe("bind socket error. sock fd: %d: %s, reason: %s", mSock->mSid,
+                    mAddr.sun_path, strerror(errno));
             mSock->close();
         }
     }
@@ -177,26 +178,23 @@ public:
     }
 };
 
-class LocIpcInetTcpSender : public LocIpcSender {
+class LocIpcInetSender : public LocIpcSender {
 protected:
+    int mSockType;
     shared_ptr<Sock> mSock;
     const string mName;
     sockaddr_in mAddr;
-    mutable bool mFirstTime;
     inline virtual bool isOperable() const override { return mSock != nullptr && mSock->isValid(); }
-    inline virtual ssize_t send(const uint8_t data[], uint32_t length, int32_t /* msgId */) const {
-        if (mFirstTime) {
-            mFirstTime = false;
-            ::connect(mSock->mSid, (const struct sockaddr*)&mAddr, sizeof(mAddr));
-        }
+    virtual ssize_t send(const uint8_t data[], uint32_t length, int32_t /* msgId */) const {
         return mSock->send(data, length, 0, (struct sockaddr*)&mAddr, sizeof(mAddr));
     }
 public:
-    inline LocIpcInetTcpSender(const char* name, int32_t port) : LocIpcSender(),
-            mSock(make_shared<Sock>((nullptr == name) ? -1 : (::socket(AF_INET, SOCK_STREAM, 0)))),
+    inline LocIpcInetSender(const char* name, int32_t port, int sockType) : LocIpcSender(),
+            mSockType(sockType),
+            mSock(make_shared<Sock>((nullptr == name) ? -1 : (::socket(AF_INET, mSockType, 0)))),
             mName((nullptr == name) ? "" : name),
-            mAddr({.sin_family=AF_INET, .sin_port=htons(port), .sin_addr={htonl(INADDR_ANY)}}),
-            mFirstTime(true) {
+            mAddr({.sin_family = AF_INET, .sin_port = htons(port),
+                    .sin_addr = {htonl(INADDR_ANY)}}) {
         if (mSock != nullptr && mSock->isValid() && nullptr != name) {
             struct hostent* hp = gethostbyname(name);
             if (nullptr != hp) {
@@ -206,7 +204,51 @@ public:
     }
 };
 
-class LocIpcInetTcpRecver : public LocIpcInetTcpSender, public LocIpcRecver {
+class LocIpcInetTcpSender : public LocIpcInetSender {
+protected:
+    mutable bool mFirstTime;
+
+    virtual ssize_t send(const uint8_t data[], uint32_t length, int32_t /* msgId */) const {
+        if (mFirstTime) {
+            mFirstTime = false;
+            ::connect(mSock->mSid, (const struct sockaddr*)&mAddr, sizeof(mAddr));
+        }
+        return mSock->send(data, length, 0, (struct sockaddr*)&mAddr, sizeof(mAddr));
+    }
+
+public:
+    inline LocIpcInetTcpSender(const char* name, int32_t port) :
+            LocIpcInetSender(name, port, SOCK_STREAM),
+            mFirstTime(true) {}
+};
+
+class LocIpcInetRecver : public LocIpcInetSender, public LocIpcRecver {
+     int32_t mPort;
+protected:
+     virtual ssize_t recv() const = 0;
+public:
+    inline LocIpcInetRecver(const shared_ptr<ILocIpcListener>& listener, const char* name,
+                               int32_t port, int sockType) :
+            LocIpcInetSender(name, port, sockType), LocIpcRecver(listener, *this),
+            mPort(port) {
+        if (mSock->isValid() && ::bind(mSock->mSid, (struct sockaddr*)&mAddr, sizeof(mAddr)) < 0) {
+            LOC_LOGe("bind socket error. sock fd: %d, reason: %s", mSock->mSid, strerror(errno));
+            mSock->close();
+        }
+    }
+    inline virtual ~LocIpcInetRecver() {}
+    inline virtual const char* getName() const override { return mName.data(); };
+    inline virtual void abort() const override {
+        if (isSendable()) {
+            sockaddr_in loopBackAddr = {.sin_family = AF_INET, .sin_port = htons(mPort),
+                    .sin_addr = {htonl(INADDR_LOOPBACK)}};
+            mSock->sendAbort(0, (struct sockaddr*)&loopBackAddr, sizeof(loopBackAddr));
+        }
+    }
+
+};
+
+class LocIpcInetTcpRecver : public LocIpcInetRecver {
     mutable int32_t mConnFd;
 protected:
     inline virtual ssize_t recv() const override {
@@ -223,21 +265,26 @@ protected:
 public:
     inline LocIpcInetTcpRecver(const shared_ptr<ILocIpcListener>& listener, const char* name,
                                int32_t port) :
-            LocIpcInetTcpSender(name, port), LocIpcRecver(listener, *this), mConnFd(-1) {
-        if (mSock->isValid() && ::bind(mSock->mSid, (struct sockaddr*)&mAddr, sizeof(mAddr)) < 0) {
-            LOC_LOGe("bind socket error. sock fd: %d, reason: %s", mSock->mSid, strerror(errno));
-            mSock->close();
-        }
-    }
-    inline virtual ~LocIpcInetTcpRecver() { if (-1 != mConnFd) ::close(mConnFd); }
-    inline virtual const char* getName() const override { return mName.data(); };
-    inline virtual void abort() const override {
-        if (isSendable()) {
-            mSock->sendAbort(0, (struct sockaddr*)&mAddr, sizeof(mAddr));
-        }
+            LocIpcInetRecver(listener, name, port, SOCK_STREAM), mConnFd(-1) {}
+    inline virtual ~LocIpcInetTcpRecver() { if (-1 != mConnFd) ::close(mConnFd);}
+};
+
+class LocIpcInetUdpRecver : public LocIpcInetRecver {
+protected:
+    inline virtual ssize_t recv() const override {
+        socklen_t size = sizeof(mAddr);
+        return mSock->recv(mDataCb, 0, (struct sockaddr*)&mAddr, &size);
     }
+public:
+    inline LocIpcInetUdpRecver(const shared_ptr<ILocIpcListener>& listener, const char* name,
+                                int32_t port) :
+            LocIpcInetRecver(listener, name, port, SOCK_DGRAM) {}
+
+    inline virtual ~LocIpcInetUdpRecver() {}
 };
 
+
+
 #ifdef NOT_DEFINED
 class LocIpcQcsiSender : public LocIpcSender {
 protected:
@@ -365,9 +412,16 @@ shared_ptr<LocIpcSender> LocIpc::getLocIpcInetTcpSender(const char* serverName,
     return make_shared<LocIpcInetTcpSender>(serverName, port);
 }
 unique_ptr<LocIpcRecver> LocIpc::getLocIpcInetTcpRecver(const shared_ptr<ILocIpcListener>& listener,
-                                                        const char* serverName, int32_t port) {
+                                                            const char* serverName, int32_t port) {
     return make_unique<LocIpcInetTcpRecver>(listener, serverName, port);
 }
+shared_ptr<LocIpcSender> LocIpc::getLocIpcInetUdpSender(const char* serverName, int32_t port) {
+    return make_shared<LocIpcInetSender>(serverName, port, SOCK_DGRAM);
+}
+unique_ptr<LocIpcRecver> LocIpc::getLocIpcInetUdpRecver(const shared_ptr<ILocIpcListener>& listener,
+                                                             const char* serverName, int32_t port) {
+    return make_unique<LocIpcInetUdpRecver>(listener, serverName, port);
+}
 pair<shared_ptr<LocIpcSender>, unique_ptr<LocIpcRecver>>
         LocIpc::getLocIpcQmiLocServiceSenderRecverPair(const shared_ptr<ILocIpcListener>& listener, int instance) {
     typedef pair<shared_ptr<LocIpcSender>, unique_ptr<LocIpcRecver>> (*creator_t)(const shared_ptr<ILocIpcListener>&, int);
diff --git a/utils/LocIpc.h b/utils/LocIpc.h
index b91966c..af4c2c3 100644
--- a/utils/LocIpc.h
+++ b/utils/LocIpc.h
@@ -67,6 +67,8 @@ public:
     static shared_ptr<LocIpcSender>
             getLocIpcLocalSender(const char* localSockName);
     static shared_ptr<LocIpcSender>
+            getLocIpcInetUdpSender(const char* serverName, int32_t port);
+    static shared_ptr<LocIpcSender>
             getLocIpcInetTcpSender(const char* serverName, int32_t port);
     static shared_ptr<LocIpcSender>
             getLocIpcQrtrSender(int service, int instance);
@@ -75,6 +77,9 @@ public:
             getLocIpcLocalRecver(const shared_ptr<ILocIpcListener>& listener,
                                  const char* localSockName);
     static unique_ptr<LocIpcRecver>
+            getLocIpcInetUdpRecver(const shared_ptr<ILocIpcListener>& listener,
+                                 const char* serverName, int32_t port);
+    static unique_ptr<LocIpcRecver>
             getLocIpcInetTcpRecver(const shared_ptr<ILocIpcListener>& listener,
                                    const char* serverName, int32_t port);
     static unique_ptr<LocIpcRecver>
@@ -122,6 +127,7 @@ protected:
     virtual bool isOperable() const = 0;
     virtual ssize_t send(const uint8_t data[], uint32_t length, int32_t msgId) const = 0;
 public:
+    virtual void informRecverRestarted() {}
     inline bool isSendable() const { return isOperable(); }
     inline bool sendData(const uint8_t data[], uint32_t length, int32_t msgId) const {
         return isSendable() && (send(data, length, msgId) > 0);
diff --git a/utils/gps_extended_c.h b/utils/gps_extended_c.h
index 9c63166..90ec339 100644
--- a/utils/gps_extended_c.h
+++ b/utils/gps_extended_c.h
@@ -372,15 +372,19 @@ typedef uint64_t GpsLocationExtendedFlags;
 /** GpsLocationExtended has Clock drift*/
 #define GPS_LOCATION_EXTENDED_HAS_CLOCK_DRIFT   0x20000000
 /** GpsLocationExtended has Clock drift std deviation**/
-#define GPS_LOCATION_EXTENDED_HAS_CLOCK_DRIFT_STD_DEV   0x40000000
+#define GPS_LOCATION_EXTENDED_HAS_CLOCK_DRIFT_STD_DEV    0x40000000
 /** GpsLocationExtended has leap seconds **/
-#define GPS_LOCATION_EXTENDED_HAS_LEAP_SECONDS   0x80000000
+#define GPS_LOCATION_EXTENDED_HAS_LEAP_SECONDS           0x80000000
 /** GpsLocationExtended has time uncertainty **/
-#define GPS_LOCATION_EXTENDED_HAS_TIME_UNC   0x100000000
+#define GPS_LOCATION_EXTENDED_HAS_TIME_UNC               0x100000000
 /** GpsLocationExtended has heading rate  **/
-#define GPS_LOCATION_EXTENDED_HAS_HEADING_RATE 0x200000000
+#define GPS_LOCATION_EXTENDED_HAS_HEADING_RATE           0x200000000
 /** GpsLocationExtended has multiband signals  **/
-#define GPS_LOCATION_EXTENDED_HAS_MULTIBAND 0x400000000
+#define GPS_LOCATION_EXTENDED_HAS_MULTIBAND              0x400000000
+/** GpsLocationExtended has sensor calibration confidence */
+#define GPS_LOCATION_EXTENDED_HAS_CALIBRATION_CONFIDENCE 0x800000000
+/** GpsLocationExtended has sensor calibration status */
+#define GPS_LOCATION_EXTENDED_HAS_CALIBRATION_STATUS     0x1000000000
 
 typedef uint32_t LocNavSolutionMask;
 /* Bitmask to specify whether SBAS ionospheric correction is used  */
@@ -397,6 +401,8 @@ typedef uint32_t LocNavSolutionMask;
 #define LOC_NAV_MASK_RTK_CORRECTION ((LocNavSolutionMask)0x0020)
 /**<  Bitmask to specify whether Position Report is PPP corrected   */
 #define LOC_NAV_MASK_PPP_CORRECTION ((LocNavSolutionMask)0x0040)
+/**<  Bitmask to specify whether Position Report is RTK fixed corrected   */
+#define LOC_NAV_MASK_RTK_FIXED_CORRECTION ((LocNavSolutionMask)0x0080)
 
 typedef uint32_t LocPosDataMask;
 /* Bitmask to specify whether Navigation data has Forward Acceleration  */
@@ -443,17 +449,6 @@ typedef uint32_t GnssAdditionalSystemInfoMask;
 #define NAVIC_SV_PRN_MIN    401
 #define NAVIC_SV_PRN_MAX    414
 
-typedef uint32_t LocPosTechMask;
-#define LOC_POS_TECH_MASK_DEFAULT ((LocPosTechMask)0x00000000)
-#define LOC_POS_TECH_MASK_SATELLITE ((LocPosTechMask)0x00000001)
-#define LOC_POS_TECH_MASK_CELLID ((LocPosTechMask)0x00000002)
-#define LOC_POS_TECH_MASK_WIFI ((LocPosTechMask)0x00000004)
-#define LOC_POS_TECH_MASK_SENSORS ((LocPosTechMask)0x00000008)
-#define LOC_POS_TECH_MASK_REFERENCE_LOCATION ((LocPosTechMask)0x00000010)
-#define LOC_POS_TECH_MASK_INJECTED_COARSE_POSITION ((LocPosTechMask)0x00000020)
-#define LOC_POS_TECH_MASK_AFLT ((LocPosTechMask)0x00000040)
-#define LOC_POS_TECH_MASK_HYBRID ((LocPosTechMask)0x00000080)
-
 typedef enum {
     LOC_RELIABILITY_NOT_SET = 0,
     LOC_RELIABILITY_VERY_LOW = 1,
@@ -462,6 +457,12 @@ typedef enum {
     LOC_RELIABILITY_HIGH = 4
 }LocReliability;
 
+typedef enum {
+    LOC_IN_EMERGENCY_UNKNOWN = 0,
+    LOC_IN_EMERGENCY_SET = 1,
+    LOC_IN_EMERGENCY_NOT_SET = 2
+}LocInEmergency;
+
 typedef struct {
     struct timespec32_t apTimeStamp;
     /*boottime received from pps-ktimer*/
@@ -497,6 +498,7 @@ typedef struct {
     uint64_t qzss_l2_sv_used_ids_mask;      // QZSS L2
     uint64_t qzss_l5_sv_used_ids_mask;      // QZSS L5
     uint64_t sbas_l1_sv_used_ids_mask;      // SBAS L1
+    uint64_t bds_b2aq_sv_used_ids_mask;     // BDS B2AQ
 } GnssSvMbUsedInPosition;
 
 /* Body Frame parameters */
@@ -605,6 +607,8 @@ typedef uint32_t GnssSignalTypeMask;
 #define GNSS_SIGNAL_SBAS_L1      ((GnssSignalTypeMask)0x00020000ul)
 /** NAVIC L5 RF Band */
 #define GNSS_SIGNAL_NAVIC_L5     ((GnssSignalTypeMask)0x00040000ul)
+/** BEIDOU B2A_Q RF Band */
+#define GNSS_SIGNAL_BEIDOU_B2AQ   ((GnssSignalTypeMask)0x00080000ul)
 
 typedef uint16_t GnssMeasUsageStatusBitMask;
 /** Used in fix */
@@ -789,6 +793,9 @@ typedef struct {
         Range: 0 to 359.999. 946
         Unit: Degrees per Seconds */
     float headingRateDeg;
+    /** Sensor calibration confidence percent. Range: 0 - 100 */
+    uint8_t calibrationConfidence;
+    DrCalibrationStatusMask calibrationStatus;
 } GpsLocationExtended;
 
 enum loc_sess_status {
@@ -1381,16 +1388,15 @@ typedef uint64_t GpsSvMeasHeaderFlags;
 #define GNSS_SV_MEAS_HEADER_HAS_GAL_SYSTEM_TIME_EXT          0x00008000
 #define GNSS_SV_MEAS_HEADER_HAS_BDS_SYSTEM_TIME_EXT          0x00010000
 #define GNSS_SV_MEAS_HEADER_HAS_QZSS_SYSTEM_TIME_EXT         0x00020000
-#define GNSS_SV_MEAS_HEADER_HAS_GPSL1L5_TIME_BIAS            0x00040000
-#define GNSS_SV_MEAS_HEADER_HAS_GALE1E5A_TIME_BIAS           0x00080000
-#define GNSS_SV_MEAS_HEADER_HAS_GPS_NAVIC_INTER_SYSTEM_BIAS  0x00100000
-#define GNSS_SV_MEAS_HEADER_HAS_GAL_NAVIC_INTER_SYSTEM_BIAS  0x00200000
-#define GNSS_SV_MEAS_HEADER_HAS_GLO_NAVIC_INTER_SYSTEM_BIAS  0x00400000
-#define GNSS_SV_MEAS_HEADER_HAS_BDS_NAVIC_INTER_SYSTEM_BIAS  0x00800000
-#define GNSS_SV_MEAS_HEADER_HAS_NAVIC_SYSTEM_TIME            0x01000000
-#define GNSS_SV_MEAS_HEADER_HAS_NAVIC_SYSTEM_TIME_EXT        0x02000000
-
-
+#define GNSS_SV_MEAS_HEADER_HAS_GLO_SYSTEM_TIME_EXT          0x00040000
+#define GNSS_SV_MEAS_HEADER_HAS_GPSL1L5_TIME_BIAS            0x00080000
+#define GNSS_SV_MEAS_HEADER_HAS_GALE1E5A_TIME_BIAS           0x00100000
+#define GNSS_SV_MEAS_HEADER_HAS_GPS_NAVIC_INTER_SYSTEM_BIAS  0x00200000
+#define GNSS_SV_MEAS_HEADER_HAS_GAL_NAVIC_INTER_SYSTEM_BIAS  0x00400000
+#define GNSS_SV_MEAS_HEADER_HAS_GLO_NAVIC_INTER_SYSTEM_BIAS  0x00800000
+#define GNSS_SV_MEAS_HEADER_HAS_BDS_NAVIC_INTER_SYSTEM_BIAS  0x01000000
+#define GNSS_SV_MEAS_HEADER_HAS_NAVIC_SYSTEM_TIME            0x02000000
+#define GNSS_SV_MEAS_HEADER_HAS_NAVIC_SYSTEM_TIME_EXT        0x04000000
 
 typedef struct
 {
@@ -1432,9 +1438,10 @@ typedef struct
     Gnss_LocGnssTimeExtStructType               bdsSystemTimeExt;
     /** QZSS system RTC time information. */
     Gnss_LocGnssTimeExtStructType               qzssSystemTimeExt;
+    /** GLONASS system RTC time information. */
+    Gnss_LocGnssTimeExtStructType               gloSystemTimeExt;
     /** NAVIC system RTC time information. */
     Gnss_LocGnssTimeExtStructType               navicSystemTimeExt;
-
 } GnssSvMeasurementHeader;
 
 typedef struct {
@@ -2190,11 +2197,12 @@ typedef void (*LocAgpsCloseResultCb)(bool isSuccess, AGpsExtType agpsType, void*
 
 #define SOCKET_LOC_CLIENT_DIR          "/dev/socket/loc_client/"
 #define EAP_LOC_CLIENT_DIR             "/data/vendor/location/extap_locclient/"
-    
+
 #define LOC_CLIENT_NAME_PREFIX         "toclient"
 
 typedef uint64_t NetworkHandle;
 #define NETWORK_HANDLE_UNKNOWN  ~0
+#define MAX_NETWORK_HANDLES 10
 
 #ifdef __cplusplus
 }
diff --git a/utils/loc_cfg.cpp b/utils/loc_cfg.cpp
index de887ee..9c1f0b3 100644
--- a/utils/loc_cfg.cpp
+++ b/utils/loc_cfg.cpp
@@ -467,6 +467,7 @@ void loc_read_conf(const char* conf_file_name, const loc_param_s_type* config_ta
 #define LOC_FEATURE_MASK_GTP_CELL_PREMIUM          0X08
 #define LOC_FEATURE_MASK_SAP_BASIC                 0x40
 #define LOC_FEATURE_MASK_SAP_PREMIUM               0X80
+#define LOC_FEATURE_MASK_GTP_WAA_BASIC             0X100
 #define LOC_FEATURE_MASK_GTP_MODEM_CELL_BASIC      0X400
 #define LOC_FEATURE_MASK_ODCPI                     0x1000
 #define LOC_FEATURE_MASK_FREE_WIFI_SCAN_INJECT     0x2000
@@ -484,6 +485,7 @@ typedef struct {
     char baseband[LOC_MAX_PARAM_STRING];
     unsigned int sglte_target;
     char feature_gtp_mode[LOC_MAX_PARAM_STRING];
+    char feature_gtp_waa[LOC_MAX_PARAM_STRING];
     char feature_sap[LOC_MAX_PARAM_STRING];
     char feature_odcpi[LOC_MAX_PARAM_STRING];
     char feature_free_wifi_scan_inject[LOC_MAX_PARAM_STRING];
@@ -504,6 +506,7 @@ static const loc_param_s_type gps_conf_parameter_table[] = {
 /* location feature conf, e.g.: izat.conf feature mode table*/
 static const loc_param_s_type loc_feature_conf_table[] = {
     {"GTP_MODE",              &conf.feature_gtp_mode,               NULL, 's'},
+    {"GTP_WAA",               &conf.feature_gtp_waa,                NULL, 's'},
     {"SAP",                   &conf.feature_sap,                    NULL, 's'},
     {"ODCPI",                 &conf.feature_odcpi,                  NULL, 's'},
     {"FREE_WIFI_SCAN_INJECT", &conf.feature_free_wifi_scan_inject,  NULL, 's'},
@@ -567,6 +570,7 @@ int loc_read_process_conf(const char* conf_file_name, uint32_t * process_count_p
     char config_mask = 0;
     unsigned char proc_list_length=0;
     int gtp_cell_ap_enabled = 0;
+    char arg_gtp_waa[LOC_PROCESS_MAX_ARG_STR_LENGTH] = "--";
     char arg_gtp_modem_cell[LOC_PROCESS_MAX_ARG_STR_LENGTH] = "--";
     char arg_gtp_wifi[LOC_PROCESS_MAX_ARG_STR_LENGTH] = "--";
     char arg_sap[LOC_PROCESS_MAX_ARG_STR_LENGTH] = "--";
@@ -582,6 +586,7 @@ int loc_read_process_conf(const char* conf_file_name, uint32_t * process_count_p
     UTIL_READ_CONF(LOC_PATH_GPS_CONF, gps_conf_parameter_table);
 
     //Form argument strings
+    strlcat(arg_gtp_waa, LOC_FEATURE_GTP_WAA, LOC_PROCESS_MAX_ARG_STR_LENGTH-3);
     strlcat(arg_gtp_modem_cell, LOC_FEATURE_GTP_MODEM_CELL, LOC_PROCESS_MAX_ARG_STR_LENGTH-3);
     strlcat(arg_gtp_wifi, LOC_FEATURE_GTP_WIFI, LOC_PROCESS_MAX_ARG_STR_LENGTH-3);
     strlcat(arg_sap, LOC_FEATURE_SAP, LOC_PROCESS_MAX_ARG_STR_LENGTH-3);
@@ -612,6 +617,19 @@ int loc_read_process_conf(const char* conf_file_name, uint32_t * process_count_p
         LOC_LOGE("%s:%d]: Unrecognized value for GTP MODE Mode."\
                  " Setting GTP WIFI to default mode: DISABLED", __func__, __LINE__);
     }
+    //Set service mask for GTP_WAA
+    if(strcmp(conf.feature_gtp_waa, "BASIC") == 0) {
+      LOC_LOGD("%s:%d]: Setting GTP WAA to mode: BASIC", __func__, __LINE__);
+      loc_service_mask |= LOC_FEATURE_MASK_GTP_WAA_BASIC;
+    }
+    else if(strcmp(conf.feature_gtp_waa, "DISABLED") == 0) {
+      LOC_LOGD("%s:%d]: GTP WAA DISABLED", __func__, __LINE__);
+    }
+    //conf file has a garbage value
+    else {
+      LOC_LOGE("%s:%d]: Unrecognized value for GTP WAA Mode."\
+               " Setting GTP WAA to default mode: DISABLED", __func__, __LINE__);
+    }
 
     //Set service mask for SAP
     if(strcmp(conf.feature_sap, "PREMIUM") == 0) {
@@ -622,6 +640,9 @@ int loc_read_process_conf(const char* conf_file_name, uint32_t * process_count_p
         LOC_LOGD("%s:%d]: Setting SAP to mode: BASIC", __func__, __LINE__);
         loc_service_mask |= LOC_FEATURE_MASK_SAP_BASIC;
     }
+    else if(strcmp(conf.feature_sap, "MODEM_DEFAULT") == 0) {
+        LOC_LOGD("%s:%d]: Setting SAP to mode: MODEM_DEFAULT", __func__, __LINE__);
+    }
     else if(strcmp(conf.feature_sap, "DISABLED") == 0) {
         LOC_LOGD("%s:%d]: Setting SAP to mode: DISABLED", __func__, __LINE__);
     }
@@ -954,6 +975,22 @@ int loc_read_process_conf(const char* conf_file_name, uint32_t * process_count_p
                                     LOC_PROCESS_MAX_ARG_STR_LENGTH);
                         }
                     }
+
+                    if(conf.loc_feature_mask & LOC_FEATURE_MASK_GTP_WAA_BASIC) {
+                      if(loc_service_mask & LOC_FEATURE_MASK_GTP_WAA_BASIC) {
+                        strlcpy(child_proc[j].args[i++], arg_gtp_waa,
+                                LOC_PROCESS_MAX_ARG_STR_LENGTH);
+                        strlcpy(child_proc[j].args[i++], arg_basic,
+                                LOC_PROCESS_MAX_ARG_STR_LENGTH);
+                      }
+                      else
+                      {
+                        strlcpy(child_proc[j].args[i++], arg_gtp_waa,
+                                LOC_PROCESS_MAX_ARG_STR_LENGTH);
+                        strlcpy(child_proc[j].args[i++], arg_disabled,
+                                LOC_PROCESS_MAX_ARG_STR_LENGTH);
+                      }
+                    }
                     IF_LOC_LOGD {
                         LOC_LOGD("%s:%d]: %s args\n", __func__, __LINE__, child_proc[j].name[0]);
                         for(unsigned int k=0; k<LOC_PROCESS_MAX_NUM_ARGS; k++) {
diff --git a/utils/loc_nmea.cpp b/utils/loc_nmea.cpp
index abcf5b7..f5090d0 100644
--- a/utils/loc_nmea.cpp
+++ b/utils/loc_nmea.cpp
@@ -36,6 +36,7 @@
 #include <loc_cfg.h>
 
 #define GLONASS_SV_ID_OFFSET 64
+#define MAX_SV_COUNT_SUPPORTED_IN_ONE_CONSTELLATION  64
 #define MAX_SATELLITES_IN_USE 12
 #define MSEC_IN_ONE_WEEK      604800000ULL
 #define UTC_GPS_OFFSET_MSECS  315964800000ULL
@@ -109,8 +110,9 @@ typedef struct loc_nmea_sv_meta_s
 {
     char talker[3];
     LocGnssConstellationType svType;
-    uint32_t mask;
+    uint64_t mask;
     uint32_t svCount;
+    uint32_t totalSvUsedCount;
     uint32_t svIdOffset;
     uint32_t signalId;
     uint32_t systemId;
@@ -118,12 +120,12 @@ typedef struct loc_nmea_sv_meta_s
 
 typedef struct loc_sv_cache_info_s
 {
-    uint32_t gps_used_mask;
-    uint32_t glo_used_mask;
-    uint32_t gal_used_mask;
-    uint32_t qzss_used_mask;
-    uint32_t bds_used_mask;
-    uint32_t navic_used_mask;
+    uint64_t gps_used_mask;
+    uint64_t glo_used_mask;
+    uint64_t gal_used_mask;
+    uint64_t qzss_used_mask;
+    uint64_t bds_used_mask;
+    uint64_t navic_used_mask;
     uint32_t gps_l1_count;
     uint32_t gps_l5_count;
     uint32_t glo_g1_count;
@@ -324,6 +326,7 @@ static uint32_t convert_signalType_to_signalId(GnssSignalTypeMask signalType)
             signalId = SIGNAL_ID_BDS_B2I;
             break;
         case GNSS_SIGNAL_BEIDOU_B2AI:
+        case GNSS_SIGNAL_BEIDOU_B2AQ:
             signalId = SIGNAL_ID_BDS_B2A;
             break;
         case GNSS_SIGNAL_NAVIC_L5:
@@ -338,6 +341,39 @@ static uint32_t convert_signalType_to_signalId(GnssSignalTypeMask signalType)
 }
 
 /*===========================================================================
+FUNCTION    get_sv_count_from_mask
+
+DESCRIPTION
+   get the sv count from bit mask
+
+DEPENDENCIES
+   NONE
+
+RETURN VALUE
+   value of sv count
+
+SIDE EFFECTS
+   N/A
+
+===========================================================================*/
+static uint32_t get_sv_count_from_mask(uint64_t svMask, int totalSvCount)
+{
+    int index = 0;
+    uint32_t svCount = 0;
+
+    if(totalSvCount > MAX_SV_COUNT_SUPPORTED_IN_ONE_CONSTELLATION) {
+        LOC_LOGE("total SV count in this constellation %d exceeded limit %d",
+                 totalSvCount, MAX_SV_COUNT_SUPPORTED_IN_ONE_CONSTELLATION);
+    }
+    for(index = 0; index < totalSvCount; index++) {
+        if(svMask & 0x1)
+            svCount += 1;
+        svMask >>= 1;
+    }
+    return svCount;
+}
+
+/*===========================================================================
 FUNCTION    loc_nmea_sv_meta_init
 
 DESCRIPTION
@@ -438,6 +474,19 @@ static loc_nmea_sv_meta* loc_nmea_sv_meta_init(loc_nmea_sv_meta& sv_meta,
             return NULL;
     }
     sv_meta.signalId = convert_signalType_to_signalId(signalType);
+    sv_meta.totalSvUsedCount =
+            get_sv_count_from_mask(sv_cache_info.gps_used_mask,
+                    GPS_SV_PRN_MAX - GPS_SV_PRN_MIN + 1) +
+            get_sv_count_from_mask(sv_cache_info.glo_used_mask,
+                    GLO_SV_PRN_MAX - GLO_SV_PRN_MIN + 1) +
+            get_sv_count_from_mask(sv_cache_info.gal_used_mask,
+                    GAL_SV_PRN_MAX - GAL_SV_PRN_MIN + 1) +
+            get_sv_count_from_mask(sv_cache_info.qzss_used_mask,
+                    QZSS_SV_PRN_MAX - QZSS_SV_PRN_MIN + 1) +
+            get_sv_count_from_mask(sv_cache_info.bds_used_mask,
+                    BDS_SV_PRN_MAX - BDS_SV_PRN_MIN + 1) +
+            get_sv_count_from_mask(sv_cache_info.navic_used_mask,
+                    NAVIC_SV_PRN_MAX - NAVIC_SV_PRN_MIN + 1);
     if (needCombine &&
                 (sv_cache_info.gps_used_mask ? 1 : 0) +
                 (sv_cache_info.glo_used_mask ? 1 : 0) +
@@ -532,27 +581,27 @@ static uint32_t loc_nmea_generate_GSA(const GpsLocationExtended &locationExtende
     int length = 0;
 
     uint32_t svUsedCount = 0;
-    uint32_t svUsedList[32] = {0};
+    uint32_t svUsedList[64] = {0};
 
     char fixType = '\0';
 
     const char* talker = sv_meta_p->talker;
     uint32_t svIdOffset = sv_meta_p->svIdOffset;
-    uint32_t mask = sv_meta_p->mask;
+    uint64_t mask = sv_meta_p->mask;
 
-    for (uint8_t i = 1; mask > 0 && svUsedCount < 32; i++)
+    for (uint8_t i = 1; mask > 0 && svUsedCount < 64; i++)
     {
         if (mask & 1)
             svUsedList[svUsedCount++] = i + svIdOffset;
         mask = mask >> 1;
     }
 
-    if (svUsedCount == 0 && GNSS_SV_TYPE_GPS != sv_meta_p->svType)
+    if (svUsedCount == 0)
         return 0;
 
-    if (svUsedCount == 0)
+    if (sv_meta_p->totalSvUsedCount == 0)
         fixType = '1'; // no fix
-    else if (svUsedCount <= 3)
+    else if (sv_meta_p->totalSvUsedCount <= 3)
         fixType = '2'; // 2D fix
     else
         fixType = '3'; // 3D fix
@@ -665,10 +714,7 @@ static void loc_nmea_generate_GSV(const GnssSvNotification &svNotify,
     int svCount = sv_meta_p->svCount;
     if (svCount <= 0)
     {
-        // no svs in view, so just send a blank $--GSV sentence
-        snprintf(sentence, lengthRemaining, "$%sGSV,1,1,0,%X", talker, sv_meta_p->signalId);
-        length = loc_nmea_put_checksum(sentence, bufSize);
-        nmeaArraystr.push_back(sentence);
+        LOC_LOGV("No SV in view for talker ID:%s, signal ID:%X", talker, sv_meta_p->signalId);
         return;
     }
 
@@ -880,7 +926,7 @@ static void loc_nmea_generate_DTM(const LocLla &ref_lla,
 }
 
 /*===========================================================================
-FUNCTION    getUtcTimeWithLeapSecondTransition
+FUNCTION    get_utctime_with_leapsecond_transition
 
 DESCRIPTION
    This function returns true if the position report is generated during
@@ -900,10 +946,12 @@ SIDE EFFECTS
    N/A
 
 ===========================================================================*/
-bool getUtcTimeWithLeapSecondTransition(const UlpLocation &location,
-                                        const GpsLocationExtended &locationExtended,
-                                        const LocationSystemInfo &systemInfo,
-                                        LocGpsUtcTime &utcPosTimestamp) {
+static bool get_utctime_with_leapsecond_transition(
+        const UlpLocation &location,
+        const GpsLocationExtended &locationExtended,
+        const LocationSystemInfo &systemInfo,
+        LocGpsUtcTime &utcPosTimestamp)
+{
     bool inTransition = false;
 
     // position report is not generated during leap second transition,
@@ -953,6 +1001,94 @@ bool getUtcTimeWithLeapSecondTransition(const UlpLocation &location,
 }
 
 /*===========================================================================
+FUNCTION    loc_nmea_get_fix_quality
+
+DESCRIPTION
+   This function obtains the fix quality for GGA sentence, mode indicator
+   for RMC and VTG sentence based on nav solution mask and tech mask in
+   the postion report.
+
+DEPENDENCIES
+   NONE
+
+Output parameter
+   ggaGpsQuality: gps quality field in GGA sentence
+   rmcModeIndicator: mode indicator field in RMC sentence
+   vtgModeIndicator: mode indicator field in VTG sentence
+
+SIDE EFFECTS
+   N/A
+
+===========================================================================*/
+static void loc_nmea_get_fix_quality(const UlpLocation & location,
+                                     const GpsLocationExtended & locationExtended,
+                                     char & ggaGpsQuality,
+                                     char & rmcModeIndicator,
+                                     char & vtgModeIndicator) {
+
+    ggaGpsQuality = '0';
+    rmcModeIndicator = 'N';
+    vtgModeIndicator = 'N';
+
+    do {
+        if (!(location.gpsLocation.flags & LOC_GPS_LOCATION_HAS_LAT_LONG)){
+            ggaGpsQuality = '0'; // 0 means no fix
+            rmcModeIndicator = 'N';
+            vtgModeIndicator = 'N';
+            break;
+        }
+        // NOTE: Order of the check is important
+        if (locationExtended.flags & GPS_LOCATION_EXTENDED_HAS_NAV_SOLUTION_MASK) {
+            if (LOC_NAV_MASK_PPP_CORRECTION & locationExtended.navSolutionMask) {
+                ggaGpsQuality = '2';    // 2 means DGPS fix
+                rmcModeIndicator = 'P'; // P means precise
+                vtgModeIndicator = 'P'; // P means precise
+                break;
+            } else if (LOC_NAV_MASK_RTK_FIXED_CORRECTION & locationExtended.navSolutionMask){
+                ggaGpsQuality = '4';    // 4 means RTK Fixed fix
+                rmcModeIndicator = 'R'; // use R (RTK fixed)
+                vtgModeIndicator = 'D'; // use D (differential) as
+                                        // no RTK fixed defined for VTG in NMEA 183 spec
+                break;
+            } else if (LOC_NAV_MASK_RTK_CORRECTION & locationExtended.navSolutionMask){
+                ggaGpsQuality = '5';    // 5 means RTK float fix
+                rmcModeIndicator = 'F'; // F means RTK float fix
+                vtgModeIndicator = 'D'; // use D (differential) as
+                                        // no RTK float defined for VTG in NMEA 183 spec
+                break;
+            } else if (LOC_NAV_MASK_DGNSS_CORRECTION & locationExtended.navSolutionMask){
+                ggaGpsQuality = '2';    // 2 means DGPS fix
+                rmcModeIndicator = 'D'; // D means differential
+                vtgModeIndicator = 'D'; // D means differential
+                break;
+            } else if (LOC_NAV_MASK_SBAS_CORRECTION_IONO & locationExtended.navSolutionMask){
+                ggaGpsQuality = '2';    // 2 means DGPS fix
+                rmcModeIndicator = 'D'; // D means differential
+                vtgModeIndicator = 'D'; // D means differential
+                break;
+            }
+        }
+        // NOTE: Order of the check is important
+        if (locationExtended.flags & GPS_LOCATION_EXTENDED_HAS_POS_TECH_MASK) {
+            if (LOC_POS_TECH_MASK_SATELLITE & locationExtended.tech_mask){
+                ggaGpsQuality = '1'; // 1 means GPS
+                rmcModeIndicator = 'A'; // A means autonomous
+                vtgModeIndicator = 'A'; // A means autonomous
+                break;
+            } else if (LOC_POS_TECH_MASK_SENSORS & locationExtended.tech_mask){
+                ggaGpsQuality = '6'; // 6 means estimated (dead reckoning)
+                rmcModeIndicator = 'E'; // E means estimated (dead reckoning)
+                vtgModeIndicator = 'E'; // E means estimated (dead reckoning)
+                break;
+            }
+        }
+    } while (0);
+
+    LOC_LOGv("gps quality: %c, rmc mode indicator: %c, vtg mode indicator: %c",
+             ggaGpsQuality, rmcModeIndicator, vtgModeIndicator);
+}
+
+/*===========================================================================
 FUNCTION    loc_nmea_generate_pos
 
 DESCRIPTION
@@ -987,7 +1123,7 @@ void loc_nmea_generate_pos(const UlpLocation &location,
     LocGpsUtcTime utcPosTimestamp = 0;
     bool inLsTransition = false;
 
-    inLsTransition = getUtcTimeWithLeapSecondTransition
+    inLsTransition = get_utctime_with_leapsecond_transition
                     (location, locationExtended, systemInfo, utcPosTimestamp);
 
     time_t utcTime(utcPosTimestamp/1000);
@@ -1035,19 +1171,22 @@ void loc_nmea_generate_pos(const UlpLocation &location,
 
     if (GPS_LOCATION_EXTENDED_HAS_GNSS_SV_USED_DATA & locationExtended.flags) {
         sv_cache_info.gps_used_mask =
-                (uint32_t)locationExtended.gnss_sv_used_ids.gps_sv_used_ids_mask;
+                locationExtended.gnss_sv_used_ids.gps_sv_used_ids_mask;
         sv_cache_info.glo_used_mask =
-                (uint32_t)locationExtended.gnss_sv_used_ids.glo_sv_used_ids_mask;
+                locationExtended.gnss_sv_used_ids.glo_sv_used_ids_mask;
         sv_cache_info.gal_used_mask =
-                (uint32_t)locationExtended.gnss_sv_used_ids.gal_sv_used_ids_mask;
-        sv_cache_info.qzss_used_mask =
-                (uint32_t)locationExtended.gnss_sv_used_ids.bds_sv_used_ids_mask;
+                locationExtended.gnss_sv_used_ids.gal_sv_used_ids_mask;
         sv_cache_info.bds_used_mask =
-                (uint32_t)locationExtended.gnss_sv_used_ids.qzss_sv_used_ids_mask;
+                locationExtended.gnss_sv_used_ids.bds_sv_used_ids_mask;
+        sv_cache_info.qzss_used_mask =
+                locationExtended.gnss_sv_used_ids.qzss_sv_used_ids_mask;
+        sv_cache_info.navic_used_mask =
+                locationExtended.gnss_sv_used_ids.navic_sv_used_ids_mask;
     }
 
     if (generate_nmea) {
         char talker[3] = {'G', 'P', '\0'};
+        char modeIndicator[7] = {0};
         uint32_t svUsedCount = 0;
         uint32_t count = 0;
         loc_nmea_sv_meta sv_meta;
@@ -1093,13 +1232,12 @@ void loc_nmea_generate_pos(const UlpLocation &location,
             talker[1] = sv_meta.talker[1];
         }
 
-        // --------------------------
-        // ---$PQGSA/$GNGSA (QZSS)---
-        // --------------------------
-
+        // ----------------------------
+        // ---$GBGSA/$GNGSA (BEIDOU)---
+        // ----------------------------
         count = loc_nmea_generate_GSA(locationExtended, sentence, sizeof(sentence),
-                        loc_nmea_sv_meta_init(sv_meta, sv_cache_info, GNSS_SV_TYPE_QZSS,
-                        GNSS_SIGNAL_QZSS_L1CA, true), nmeaArraystr);
+                        loc_nmea_sv_meta_init(sv_meta, sv_cache_info, GNSS_SV_TYPE_BEIDOU,
+                        GNSS_SIGNAL_BEIDOU_B1I, true), nmeaArraystr);
         if (count > 0)
         {
             svUsedCount += count;
@@ -1107,12 +1245,13 @@ void loc_nmea_generate_pos(const UlpLocation &location,
             talker[1] = sv_meta.talker[1];
         }
 
-        // ----------------------------
-        // ---$PQGSA/$GNGSA (BEIDOU)---
-        // ----------------------------
+        // --------------------------
+        // ---$GQGSA/$GNGSA (QZSS)---
+        // --------------------------
+
         count = loc_nmea_generate_GSA(locationExtended, sentence, sizeof(sentence),
-                        loc_nmea_sv_meta_init(sv_meta, sv_cache_info, GNSS_SV_TYPE_BEIDOU,
-                        GNSS_SIGNAL_BEIDOU_B1I, true), nmeaArraystr);
+                        loc_nmea_sv_meta_init(sv_meta, sv_cache_info, GNSS_SV_TYPE_QZSS,
+                        GNSS_SIGNAL_QZSS_L1CA, true), nmeaArraystr);
         if (count > 0)
         {
             svUsedCount += count;
@@ -1120,6 +1259,12 @@ void loc_nmea_generate_pos(const UlpLocation &location,
             talker[1] = sv_meta.talker[1];
         }
 
+        char ggaGpsQuality = '0';
+        char rmcModeIndicator = 'N';
+        char vtgModeIndicator = 'N';
+        loc_nmea_get_fix_quality(location, locationExtended,
+                                 ggaGpsQuality, rmcModeIndicator, vtgModeIndicator);
+
         // -------------------
         // ------$--VTG-------
         // -------------------
@@ -1174,17 +1319,7 @@ void loc_nmea_generate_pos(const UlpLocation &location,
         pMarker += length;
         lengthRemaining -= length;
 
-        if (!(location.gpsLocation.flags & LOC_GPS_LOCATION_HAS_LAT_LONG))
-            // N means no fix
-            length = snprintf(pMarker, lengthRemaining, "%c", 'N');
-        else if (LOC_NAV_MASK_SBAS_CORRECTION_IONO & locationExtended.navSolutionMask)
-            // D means differential
-            length = snprintf(pMarker, lengthRemaining, "%c", 'D');
-        else if (LOC_POS_TECH_MASK_SENSORS == locationExtended.tech_mask)
-            // E means estimated (dead reckoning)
-            length = snprintf(pMarker, lengthRemaining, "%c", 'E');
-        else // A means autonomous
-            length = snprintf(pMarker, lengthRemaining, "%c", 'A');
+        length = snprintf(pMarker, lengthRemaining, "%c", vtgModeIndicator);
 
         length = loc_nmea_put_checksum(sentence, sizeof(sentence));
         nmeaArraystr.push_back(sentence);
@@ -1372,18 +1507,7 @@ void loc_nmea_generate_pos(const UlpLocation &location,
         pMarker += length;
         lengthRemaining -= length;
 
-        if (!(location.gpsLocation.flags & LOC_GPS_LOCATION_HAS_LAT_LONG))
-            // N means no fix
-            length = snprintf(pMarker, lengthRemaining, "%c", 'N');
-        else if (LOC_NAV_MASK_SBAS_CORRECTION_IONO & locationExtended.navSolutionMask)
-            // D means differential
-            length = snprintf(pMarker, lengthRemaining, "%c", 'D');
-        else if (LOC_POS_TECH_MASK_SENSORS == locationExtended.tech_mask)
-            // E means estimated (dead reckoning)
-            length = snprintf(pMarker, lengthRemaining, "%c", 'E');
-        else  // A means autonomous
-            length = snprintf(pMarker, lengthRemaining, "%c", 'A');
-
+        length = snprintf(pMarker, lengthRemaining, "%c", rmcModeIndicator);
         pMarker += length;
         lengthRemaining -= length;
 
@@ -1461,17 +1585,49 @@ void loc_nmea_generate_pos(const UlpLocation &location,
         pMarker += length;
         lengthRemaining -= length;
 
-        if (!(location.gpsLocation.flags & LOC_GPS_LOCATION_HAS_LAT_LONG))
-            // N means no fix
-            length = snprintf(pMarker, lengthRemaining, "%c,", 'N');
+        if(!(sv_cache_info.gps_used_mask ? 1 : 0))
+            modeIndicator[0] = 'N';
         else if (LOC_NAV_MASK_SBAS_CORRECTION_IONO & locationExtended.navSolutionMask)
-            // D means differential
-            length = snprintf(pMarker, lengthRemaining, "%c,", 'D');
+            modeIndicator[0] = 'D';
+        else if (LOC_POS_TECH_MASK_SENSORS == locationExtended.tech_mask)
+            modeIndicator[0] = 'E';
+        else
+            modeIndicator[0] = 'A';
+        if(!(sv_cache_info.glo_used_mask ? 1 : 0))
+            modeIndicator[1] = 'N';
+        else if (LOC_POS_TECH_MASK_SENSORS == locationExtended.tech_mask)
+            modeIndicator[1] = 'E';
+        else
+            modeIndicator[1] = 'A';
+        if(!(sv_cache_info.gal_used_mask ? 1 : 0))
+            modeIndicator[2] = 'N';
+        else if (LOC_POS_TECH_MASK_SENSORS == locationExtended.tech_mask)
+            modeIndicator[2] = 'E';
+        else
+            modeIndicator[2] = 'A';
+        if(!(sv_cache_info.bds_used_mask ? 1 : 0))
+            modeIndicator[3] = 'N';
+        else if (LOC_POS_TECH_MASK_SENSORS == locationExtended.tech_mask)
+            modeIndicator[3] = 'E';
+        else
+            modeIndicator[3] = 'A';
+        if(!(sv_cache_info.qzss_used_mask ? 1 : 0))
+            modeIndicator[4] = 'N';
+        else if (LOC_POS_TECH_MASK_SENSORS == locationExtended.tech_mask)
+            modeIndicator[4] = 'E';
+        else
+            modeIndicator[4] = 'A';
+        if(!(sv_cache_info.navic_used_mask ? 1 : 0))
+            modeIndicator[5] = 'N';
         else if (LOC_POS_TECH_MASK_SENSORS == locationExtended.tech_mask)
-            // E means estimated (dead reckoning)
-            length = snprintf(pMarker, lengthRemaining, "%c,", 'E');
-        else  // A means autonomous
-            length = snprintf(pMarker, lengthRemaining, "%c,", 'A');
+            modeIndicator[5] = 'E';
+        else
+            modeIndicator[5] = 'A';
+        modeIndicator[6] = '\0';
+        for(int index = 5; index > 0 && 'N' == modeIndicator[index]; index--) {
+            modeIndicator[index] = '\0';
+        }
+        length = snprintf(pMarker, lengthRemaining,"%s,", modeIndicator);
 
         pMarker += length;
         lengthRemaining -= length;
@@ -1600,28 +1756,18 @@ void loc_nmea_generate_pos(const UlpLocation &location,
         pMarker += length;
         lengthRemaining -= length;
 
-        char gpsQuality;
-        if (!(location.gpsLocation.flags & LOC_GPS_LOCATION_HAS_LAT_LONG))
-            gpsQuality = '0'; // 0 means no fix
-        else if (LOC_NAV_MASK_SBAS_CORRECTION_IONO & locationExtended.navSolutionMask)
-            gpsQuality = '2'; // 2 means DGPS fix
-        else if (LOC_POS_TECH_MASK_SENSORS == locationExtended.tech_mask)
-            gpsQuality = '6'; // 6 means estimated (dead reckoning)
-        else
-            gpsQuality = '1'; // 1 means GPS fix
-
         // Number of satellites in use, 00-12
         if (svUsedCount > MAX_SATELLITES_IN_USE)
             svUsedCount = MAX_SATELLITES_IN_USE;
         if (locationExtended.flags & GPS_LOCATION_EXTENDED_HAS_DOP)
         {
             length = snprintf(pMarker, lengthRemaining, "%c,%02d,%.1f,",
-                              gpsQuality, svUsedCount, locationExtended.hdop);
+                              ggaGpsQuality, svUsedCount, locationExtended.hdop);
         }
         else
         {   // no hdop
             length = snprintf(pMarker, lengthRemaining, "%c,%02d,,",
-                              gpsQuality, svUsedCount);
+                              ggaGpsQuality, svUsedCount);
         }
 
         if (length < 0 || length >= lengthRemaining)
@@ -1687,10 +1833,6 @@ void loc_nmea_generate_pos(const UlpLocation &location,
         length = loc_nmea_put_checksum(sentence, sizeof(sentence));
         nmeaArraystr.push_back(sentence);
 
-        strlcpy(sentence, "$GNGSA,A,1,,,,,,,,,,,,,,,,", sizeof(sentence));
-        length = loc_nmea_put_checksum(sentence, sizeof(sentence));
-        nmeaArraystr.push_back(sentence);
-
         strlcpy(sentence, "$GPVTG,,T,,M,,N,,K,N", sizeof(sentence));
         length = loc_nmea_put_checksum(sentence, sizeof(sentence));
         nmeaArraystr.push_back(sentence);