seed: Squashed update to LA.BR.1.2.9_rb1.14

Change-Id: Ib85e6d98f68de19456e460a853dfa3ed44dfab60
author: Michael Bestas <mkbestas@lineageos.org> 2017-05-04 03:22:47 +0300
committer: Rygebin <kaankulahli@gmail.com> 2017-06-24 09:32:17 +0000
commit: 30a0d0c9492bdcc107de0f87207dec7b97ab4456 (patch)
tree: fa2026e95376eaa8baa6f6adba7e9ed04e2c8957
parent: 5a4a4ae55a32ee5003a008ffe4a357987c1a418b (diff)
26 files changed, 789 insertions, 383 deletions
diff --git a/gps/core/ContextBase.cpp b/gps/core/ContextBase.cpp
index 9f6c4aa..971354d 100644
--- a/gps/core/ContextBase.cpp
+++ b/gps/core/ContextBase.cpp
@@ -40,6 +40,27 @@
 
 namespace loc_core {
 
+loc_gps_cfg_s_type ContextBase::mGps_conf {0};
+loc_sap_cfg_s_type ContextBase::mSap_conf {0};
+
+uint32_t ContextBase::getCarrierCapabilities() {
+    #define carrierMSA (uint32_t)0x2
+    #define carrierMSB (uint32_t)0x1
+    #define gpsConfMSA (uint32_t)0x4
+    #define gpsConfMSB (uint32_t)0x2
+    uint32_t capabilities = mGps_conf.CAPABILITIES;
+    if ((mGps_conf.SUPL_MODE & carrierMSA) != carrierMSA) {
+        capabilities &= ~gpsConfMSA;
+    }
+    if ((mGps_conf.SUPL_MODE & carrierMSB) != carrierMSB) {
+        capabilities &= ~gpsConfMSB;
+    }
+
+    LOC_LOGV("getCarrierCapabilities: CAPABILITIES %x, SUPL_MODE %x, carrier capabilities %x",
+             mGps_conf.CAPABILITIES, mGps_conf.SUPL_MODE, capabilities);
+    return capabilities;
+}
+
 LBSProxyBase* ContextBase::getLBSProxy(const char* libName)
 {
     LBSProxyBase* proxy = NULL;
diff --git a/gps/core/ContextBase.h b/gps/core/ContextBase.h
index fe0b860..4f7ac39 100644
--- a/gps/core/ContextBase.h
+++ b/gps/core/ContextBase.h
@@ -35,6 +35,67 @@
 #include <LocApiBase.h>
 #include <LBSProxyBase.h>
 
+#define MAX_XTRA_SERVER_URL_LENGTH 256
+
+/* GPS.conf support */
+/* NOTE: the implementaiton of the parser casts number
+   fields to 32 bit. To ensure all 'n' fields working,
+   they must all be 32 bit fields. */
+typedef struct loc_gps_cfg_s
+{
+    uint32_t       INTERMEDIATE_POS;
+    uint32_t       ACCURACY_THRES;
+    uint32_t       SUPL_VER;
+    uint32_t       SUPL_MODE;
+    uint32_t       SUPL_ES;
+    uint32_t       CAPABILITIES;
+    uint32_t       LPP_PROFILE;
+    uint32_t       XTRA_VERSION_CHECK;
+    char           XTRA_SERVER_1[MAX_XTRA_SERVER_URL_LENGTH];
+    char           XTRA_SERVER_2[MAX_XTRA_SERVER_URL_LENGTH];
+    char           XTRA_SERVER_3[MAX_XTRA_SERVER_URL_LENGTH];
+    uint32_t       USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL;
+    uint32_t       NMEA_PROVIDER;
+    uint32_t       GPS_LOCK;
+    uint32_t       A_GLONASS_POS_PROTOCOL_SELECT;
+    uint32_t       AGPS_CERT_WRITABLE_MASK;
+    uint32_t       LPPE_CP_TECHNOLOGY;
+    uint32_t       LPPE_UP_TECHNOLOGY;
+} loc_gps_cfg_s_type;
+
+/* NOTE: the implementaiton of the parser casts number
+   fields to 32 bit. To ensure all 'n' fields working,
+   they must all be 32 bit fields. */
+/* Meanwhile, *_valid fields are 8 bit fields, and 'f'
+   fields are double. Rigid as they are, it is the
+   the status quo, until the parsing mechanism is
+   change, that is. */
+typedef struct
+{
+    uint8_t        GYRO_BIAS_RANDOM_WALK_VALID;
+    double         GYRO_BIAS_RANDOM_WALK;
+    uint32_t       SENSOR_ACCEL_BATCHES_PER_SEC;
+    uint32_t       SENSOR_ACCEL_SAMPLES_PER_BATCH;
+    uint32_t       SENSOR_GYRO_BATCHES_PER_SEC;
+    uint32_t       SENSOR_GYRO_SAMPLES_PER_BATCH;
+    uint32_t       SENSOR_ACCEL_BATCHES_PER_SEC_HIGH;
+    uint32_t       SENSOR_ACCEL_SAMPLES_PER_BATCH_HIGH;
+    uint32_t       SENSOR_GYRO_BATCHES_PER_SEC_HIGH;
+    uint32_t       SENSOR_GYRO_SAMPLES_PER_BATCH_HIGH;
+    uint32_t       SENSOR_CONTROL_MODE;
+    uint32_t       SENSOR_USAGE;
+    uint32_t       SENSOR_ALGORITHM_CONFIG_MASK;
+    uint8_t        ACCEL_RANDOM_WALK_SPECTRAL_DENSITY_VALID;
+    double         ACCEL_RANDOM_WALK_SPECTRAL_DENSITY;
+    uint8_t        ANGLE_RANDOM_WALK_SPECTRAL_DENSITY_VALID;
+    double         ANGLE_RANDOM_WALK_SPECTRAL_DENSITY;
+    uint8_t        RATE_RANDOM_WALK_SPECTRAL_DENSITY_VALID;
+    double         RATE_RANDOM_WALK_SPECTRAL_DENSITY;
+    uint8_t        VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY_VALID;
+    double         VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY;
+    uint32_t       SENSOR_PROVIDER;
+} loc_sap_cfg_s_type;
+
 namespace loc_core {
 
 class LocAdapterBase;
@@ -58,6 +119,7 @@ public:
     inline LocApiProxyBase* getLocApiProxy() { return mLocApiProxy; }
     inline bool hasAgpsExtendedCapabilities() { return mLBSProxy->hasAgpsExtendedCapabilities(); }
     inline bool hasCPIExtendedCapabilities() { return mLBSProxy->hasCPIExtendedCapabilities(); }
+    inline bool hasNativeXtraClient() { return mLBSProxy->hasNativeXtraClient(); }
     inline void modemPowerVote(bool power) const { return mLBSProxy->modemPowerVote(power); }
     inline void requestUlp(LocAdapterBase* adapter,
                            unsigned long capabilities) {
@@ -67,6 +129,12 @@ public:
         return mLBSProxy->getIzatDevId();
     }
     inline void sendMsg(const LocMsg *msg) { getMsgTask()->sendMsg(msg); }
+
+    static loc_gps_cfg_s_type mGps_conf;
+    static loc_sap_cfg_s_type mSap_conf;
+
+    static uint32_t getCarrierCapabilities();
+
 };
 
 } // namespace loc_core
diff --git a/gps/core/LBSProxyBase.h b/gps/core/LBSProxyBase.h
index b3736c2..94ddd0f 100644
--- a/gps/core/LBSProxyBase.h
+++ b/gps/core/LBSProxyBase.h
@@ -69,6 +69,7 @@ public:
 
         (void)context;
     }
+    inline virtual bool hasNativeXtraClient() const { return false; }
     inline virtual IzatDevId_t getIzatDevId() const { return 0; }
 };
 
diff --git a/gps/core/LocAdapterBase.cpp b/gps/core/LocAdapterBase.cpp
index fbd077a..d4727d8 100644
--- a/gps/core/LocAdapterBase.cpp
+++ b/gps/core/LocAdapterBase.cpp
@@ -80,7 +80,7 @@ void LocAdapterBase::
 }
 
 void LocAdapterBase::
-    reportSv(QcomSvStatus &svStatus,
+    reportSv(GnssSvStatus &svStatus,
              GpsLocationExtended &locationExtended,
              void* svExt)
 DEFAULT_IMPL()
@@ -137,6 +137,6 @@ bool LocAdapterBase::
 DEFAULT_IMPL(false)
 
 void LocAdapterBase::
-    reportGpsMeasurementData(GpsData &gpsMeasurementData)
+    reportGnssMeasurementData(GnssData &gnssMeasurementData)
 DEFAULT_IMPL()
 } // namespace loc_core
diff --git a/gps/core/LocAdapterBase.h b/gps/core/LocAdapterBase.h
index 2268062..2c7a2e8 100644
--- a/gps/core/LocAdapterBase.h
+++ b/gps/core/LocAdapterBase.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2011-2014, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2011-2014,2016 The Linux Foundation. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
@@ -78,6 +78,10 @@ public:
         mLocApi->updateEvtMask();
     }
 
+    inline bool isFeatureSupported(uint8_t featureVal) {
+        return mLocApi->isFeatureSupported(featureVal);
+    }
+
     // This will be overridden by the individual adapters
     // if necessary.
     inline virtual void setUlpProxy(UlpProxyBase* ulp) {
@@ -98,7 +102,7 @@ public:
                                 void* locationExt,
                                 enum loc_sess_status status,
                                 LocPosTechMask loc_technology_mask);
-    virtual void reportSv(QcomSvStatus &svStatus,
+    virtual void reportSv(GnssSvStatus &svStatus,
                           GpsLocationExtended &locationExtended,
                           void* svExt);
     virtual void reportStatus(GpsStatusValue status);
@@ -117,7 +121,7 @@ public:
                                  const void* data);
     inline virtual bool isInSession() { return false; }
     ContextBase* getContext() const { return mContext; }
-    virtual void reportGpsMeasurementData(GpsData &gpsMeasurementData);
+    virtual void reportGnssMeasurementData(GnssData &gnssMeasurementData);
 };
 
 } // namespace loc_core
diff --git a/gps/core/LocAdapterProxyBase.h b/gps/core/LocAdapterProxyBase.h
index 11859de..82cba6b 100644
--- a/gps/core/LocAdapterProxyBase.h
+++ b/gps/core/LocAdapterProxyBase.h
@@ -46,15 +46,15 @@ protected:
     inline virtual ~LocAdapterProxyBase() {
         delete mLocAdapterBase;
     }
-    ContextBase* getContext() const {
-        return mLocAdapterBase->getContext();
-    }
     inline void updateEvtMask(LOC_API_ADAPTER_EVENT_MASK_T event,
                               loc_registration_mask_status isEnabled) {
         mLocAdapterBase->updateEvtMask(event,isEnabled);
     }
 
 public:
+    inline ContextBase* getContext() const {
+        return mLocAdapterBase->getContext();
+    }
     inline virtual void handleEngineUpEvent() {};
     inline virtual void handleEngineDownEvent() {};
     inline virtual bool reportPosition(UlpLocation &location,
diff --git a/gps/core/LocApiBase.cpp b/gps/core/LocApiBase.cpp
index 8247d0a..5ff7931 100644
--- a/gps/core/LocApiBase.cpp
+++ b/gps/core/LocApiBase.cpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2011-2014, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2011-2014,2016 The Linux Foundation. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
@@ -132,6 +132,7 @@ LocApiBase::LocApiBase(const MsgTask* msgTask,
     mMask(0), mSupportedMsg(0), mContext(context)
 {
     memset(mLocAdapters, 0, sizeof(mLocAdapters));
+    memset(mFeaturesSupported, 0, sizeof(mFeaturesSupported));
 }
 
 LOC_API_ADAPTER_EVENT_MASK_T LocApiBase::getEvtMask()
@@ -236,13 +237,18 @@ void LocApiBase::reportPosition(UlpLocation &location,
     LOC_LOGV("flags: %d\n  source: %d\n  latitude: %f\n  longitude: %f\n  "
              "altitude: %f\n  speed: %f\n  bearing: %f\n  accuracy: %f\n  "
              "timestamp: %lld\n  rawDataSize: %d\n  rawData: %p\n  "
-             "Session status: %d\n Technology mask: %u",
+             "Session status: %d\n Technology mask: %u\n "
+             "SV used in fix (gps/glo/bds/gal) : (%x/%x/%x/%x)",
              location.gpsLocation.flags, location.position_source,
              location.gpsLocation.latitude, location.gpsLocation.longitude,
              location.gpsLocation.altitude, location.gpsLocation.speed,
              location.gpsLocation.bearing, location.gpsLocation.accuracy,
              location.gpsLocation.timestamp, location.rawDataSize,
-             location.rawData, status, loc_technology_mask);
+             location.rawData, status, loc_technology_mask,
+             locationExtended.gnss_sv_used_ids.gps_sv_used_ids_mask,
+             locationExtended.gnss_sv_used_ids.glo_sv_used_ids_mask,
+             locationExtended.gnss_sv_used_ids.bds_sv_used_ids_mask,
+             locationExtended.gnss_sv_used_ids.gal_sv_used_ids_mask);
     // loop through adapters, and deliver to all adapters.
     TO_ALL_LOCADAPTERS(
         mLocAdapters[i]->reportPosition(location,
@@ -253,23 +259,21 @@ void LocApiBase::reportPosition(UlpLocation &location,
     );
 }
 
-void LocApiBase::reportSv(QcomSvStatus &svStatus,
+void LocApiBase::reportSv(GnssSvStatus &svStatus,
                   GpsLocationExtended &locationExtended,
                   void* svExt)
 {
     // print the SV info before delivering
-    LOC_LOGV("num sv: %d\n  ephemeris mask: %dxn  almanac mask: %x\n  gps/glo/bds in use"
-             " mask: %x/%x/%x\n      sv: prn         snr       elevation      azimuth",
-             svStatus.num_svs, svStatus.ephemeris_mask,
-             svStatus.almanac_mask, svStatus.gps_used_in_fix_mask,
-             svStatus.glo_used_in_fix_mask, svStatus.bds_used_in_fix_mask);
-    for (int i = 0; i < svStatus.num_svs && i < GPS_MAX_SVS; i++) {
-        LOC_LOGV("   %d:   %d    %f    %f    %f",
+    LOC_LOGV("num sv: %d", svStatus.num_svs);
+    for (int i = 0; i < svStatus.num_svs && i < GNSS_MAX_SVS; i++) {
+        LOC_LOGV("   %03d:   %02d    %d    %f    %f    %f   0x%02X",
                  i,
-                 svStatus.sv_list[i].prn,
-                 svStatus.sv_list[i].snr,
-                 svStatus.sv_list[i].elevation,
-                 svStatus.sv_list[i].azimuth);
+                 svStatus.gnss_sv_list[i].svid,
+                 svStatus.gnss_sv_list[i].constellation,
+                 svStatus.gnss_sv_list[i].c_n0_dbhz,
+                 svStatus.gnss_sv_list[i].elevation,
+                 svStatus.gnss_sv_list[i].azimuth,
+                 svStatus.gnss_sv_list[i].flags);
     }
     // loop through adapters, and deliver to all adapters.
     TO_ALL_LOCADAPTERS(
@@ -358,16 +362,21 @@ void LocApiBase::saveSupportedMsgList(uint64_t supportedMsgList)
     mSupportedMsg = supportedMsgList;
 }
 
+void LocApiBase::saveSupportedFeatureList(uint8_t *featureList)
+{
+    memcpy((void *)mFeaturesSupported, (void *)featureList, sizeof(mFeaturesSupported));
+}
+
 void* LocApiBase :: getSibling()
     DEFAULT_IMPL(NULL)
 
 LocApiProxyBase* LocApiBase :: getLocApiProxy()
     DEFAULT_IMPL(NULL)
 
-void LocApiBase::reportGpsMeasurementData(GpsData &gpsMeasurementData)
+void LocApiBase::reportGnssMeasurementData(GnssData &gnssMeasurementData)
 {
     // loop through adapters, and deliver to all adapters.
-    TO_ALL_LOCADAPTERS(mLocAdapters[i]->reportGpsMeasurementData(gpsMeasurementData));
+    TO_ALL_LOCADAPTERS(mLocAdapters[i]->reportGnssMeasurementData(gnssMeasurementData));
 }
 
 enum loc_api_adapter_err LocApiBase::
@@ -446,6 +455,10 @@ enum loc_api_adapter_err LocApiBase::
 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
 
 enum loc_api_adapter_err LocApiBase::
+    setNMEATypes (uint32_t typesMask)
+DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
+
+enum loc_api_adapter_err LocApiBase::
     setLPPConfig(uint32_t profile)
 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
 
@@ -481,12 +494,12 @@ enum loc_api_adapter_err LocApiBase::
 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
 
 enum loc_api_adapter_err LocApiBase::
-    setExtPowerConfig(int isBatteryCharging)
+    setAGLONASSProtocol(unsigned long aGlonassProtocol)
 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
 
 enum loc_api_adapter_err LocApiBase::
-    setAGLONASSProtocol(unsigned long aGlonassProtocol)
-DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
+        setLPPeProtocol(unsigned long lppeCP, unsigned long lppeUP)
+    DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
 
 enum loc_api_adapter_err LocApiBase::
    getWwanZppFix(GpsLocation& zppLoc)
@@ -550,4 +563,14 @@ bool LocApiBase::
     gnssConstellationConfig()
 DEFAULT_IMPL(false)
 
+bool LocApiBase::
+    isFeatureSupported(uint8_t featureVal)
+{
+    uint8_t arrayIndex = featureVal >> 3;
+    uint8_t bitPos = featureVal & 7;
+
+    if (arrayIndex >= MAX_FEATURE_LENGTH) return false;
+    return ((mFeaturesSupported[arrayIndex] >> bitPos ) & 0x1);
+}
+
 } // namespace loc_core
diff --git a/gps/core/LocApiBase.h b/gps/core/LocApiBase.h
index 18f8623..0edc469 100644
--- a/gps/core/LocApiBase.h
+++ b/gps/core/LocApiBase.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2011-2014, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2011-2014, 2016 The Linux Foundation. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
@@ -44,6 +44,7 @@ int decodeAddress(char *addr_string, int string_size,
                   const char *data, int data_size);
 
 #define MAX_ADAPTERS          10
+#define MAX_FEATURE_LENGTH    100
 
 #define TO_ALL_ADAPTERS(adapters, call)                                \
     for (int i = 0; i < MAX_ADAPTERS && NULL != (adapters)[i]; i++) {  \
@@ -81,6 +82,7 @@ class LocApiBase {
     ContextBase *mContext;
     LocAdapterBase* mLocAdapters[MAX_ADAPTERS];
     uint64_t mSupportedMsg;
+    uint8_t mFeaturesSupported[MAX_FEATURE_LENGTH];
 
 protected:
     virtual enum loc_api_adapter_err
@@ -113,7 +115,7 @@ public:
                         enum loc_sess_status status,
                         LocPosTechMask loc_technology_mask =
                                   LOC_POS_TECH_MASK_DEFAULT);
-    void reportSv(QcomSvStatus &svStatus,
+    void reportSv(GnssSvStatus &svStatus,
                   GpsLocationExtended &locationExtended,
                   void* svExt);
     void reportStatus(GpsStatusValue status);
@@ -130,7 +132,8 @@ public:
     void reportDataCallClosed();
     void requestNiNotify(GpsNiNotification &notify, const void* data);
     void saveSupportedMsgList(uint64_t supportedMsgList);
-    void reportGpsMeasurementData(GpsData &gpsMeasurementData);
+    void reportGnssMeasurementData(GnssData &gnssMeasurementData);
+    void saveSupportedFeatureList(uint8_t *featureList);
 
     // downward calls
     // All below functions are to be defined by adapter specific modules:
@@ -172,6 +175,8 @@ public:
     virtual enum loc_api_adapter_err
         setSUPLVersion(uint32_t version);
     virtual enum loc_api_adapter_err
+        setNMEATypes (uint32_t typesMask);
+    virtual enum loc_api_adapter_err
         setLPPConfig(uint32_t profile);
     virtual enum loc_api_adapter_err
         setSensorControlConfig(int sensorUsage, int sensorProvider);
@@ -198,10 +203,10 @@ public:
                                int gyroBatchesPerSecHigh,
                                int algorithmConfig);
     virtual enum loc_api_adapter_err
-        setExtPowerConfig(int isBatteryCharging);
-    virtual enum loc_api_adapter_err
         setAGLONASSProtocol(unsigned long aGlonassProtocol);
     virtual enum loc_api_adapter_err
+        setLPPeProtocol(unsigned long lppeCP, unsigned long lppeUP);
+    virtual enum loc_api_adapter_err
         getWwanZppFix(GpsLocation & zppLoc);
     virtual enum loc_api_adapter_err
         getBestAvailableZppFix(GpsLocation & zppLoc);
@@ -256,6 +261,11 @@ public:
       Check if the modem support the service
      */
     virtual bool gnssConstellationConfig();
+
+    /*
+       Check if a feature is supported
+      */
+    bool isFeatureSupported(uint8_t featureVal);
 };
 
 typedef LocApiBase* (getLocApi_t)(const MsgTask* msgTask,
diff --git a/gps/core/UlpProxyBase.h b/gps/core/UlpProxyBase.h
index 92507bc..7e608cd 100644
--- a/gps/core/UlpProxyBase.h
+++ b/gps/core/UlpProxyBase.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2013-2015, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2013-2016, The Linux Foundation. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
@@ -33,7 +33,7 @@
 #ifndef OSS_BUILD
 #include "fused_location_extended.h"
 #else
-struct FlpExtLocation;
+struct FlpExtLocation_s;
 struct FlpExtBatchOptions;
 #endif
 
@@ -69,7 +69,7 @@ public:
         (void)loc_technology_mask;
         return false;
     }
-    inline virtual bool reportSv(QcomSvStatus &svStatus,
+    inline virtual bool reportSv(GnssSvStatus &svStatus,
                                  GpsLocationExtended &locationExtended,
                                  void* svExt) {
         (void)svStatus;
@@ -97,7 +97,7 @@ public:
         (void)active;
         return false;
     }
-    inline virtual bool reportPositions(const FlpExtLocation* locations,
+    inline virtual bool reportPositions(const struct FlpExtLocation_s* locations,
                                         int32_t number_of_locations) {
         (void)locations;
         (void)number_of_locations;
diff --git a/gps/core/gps_extended_c.h b/gps/core/gps_extended_c.h
index b3c1092..4815dd6 100644
--- a/gps/core/gps_extended_c.h
+++ b/gps/core/gps_extended_c.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2013-2015, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2013-2015, 2016 The Linux Foundation. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
@@ -77,17 +77,34 @@ extern "C" {
 #define AGPS_CERTIFICATE_MAX_LENGTH 2000
 #define AGPS_CERTIFICATE_MAX_SLOTS 10
 
+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)
+
 enum loc_registration_mask_status {
     LOC_REGISTRATION_MASK_ENABLED,
     LOC_REGISTRATION_MASK_DISABLED
 };
 
+typedef enum {
+    LOC_SUPPORTED_FEATURE_ODCPI_2_V02 = 0, /**<  Support ODCPI version 2 feature  */
+    LOC_SUPPORTED_FEATURE_WIFI_AP_DATA_INJECT_2_V02 /**<  Support Wifi AP data inject version 2 feature  */
+} loc_supported_feature_enum;
+
 typedef struct {
     /** set to sizeof(UlpLocation) */
     size_t          size;
     GpsLocation     gpsLocation;
     /* Provider indicator for HYBRID or GPS */
     uint16_t        position_source;
+    LocPosTechMask  tech_mask;
     /*allows HAL to pass additional information related to the location */
     int             rawDataSize;         /* in # of bytes */
     void            * rawData;
@@ -165,14 +182,14 @@ typedef struct {
 } AGpsExtCallbacks;
 
 
+typedef void (*loc_ni_notify_callback)(GpsNiNotification *notification, bool esEnalbed);
 /** GPS NI callback structure. */
 typedef struct
 {
     /**
      * Sends the notification request from HAL to GPSLocationProvider.
      */
-    gps_ni_notify_callback notify_cb;
-    gps_create_thread create_thread_cb;
+    loc_ni_notify_callback notify_cb;
 } GpsNiExtCallbacks;
 
 typedef enum loc_server_type {
@@ -217,6 +234,24 @@ typedef uint16_t GpsLocationExtendedFlags;
 #define GPS_LOCATION_EXTENDED_HAS_HOR_RELIABILITY 0x0080
 /** GpsLocationExtended has valid vertical reliability */
 #define GPS_LOCATION_EXTENDED_HAS_VERT_RELIABILITY 0x0100
+/** GpsLocationExtended has valid Horizontal Elliptical Uncertainty (Semi-Major Axis) */
+#define GPS_LOCATION_EXTENDED_HAS_HOR_ELIP_UNC_MAJOR 0x0200
+/** GpsLocationExtended has valid Horizontal Elliptical Uncertainty (Semi-Minor Axis) */
+#define GPS_LOCATION_EXTENDED_HAS_HOR_ELIP_UNC_MINOR 0x0400
+/** GpsLocationExtended has valid Elliptical Horizontal Uncertainty Azimuth */
+#define GPS_LOCATION_EXTENDED_HAS_HOR_ELIP_UNC_AZIMUTH 0x0800
+/** GpsLocationExtended has valid gnss sv used in position data */
+#define GPS_LOCATION_EXTENDED_HAS_GNSS_SV_USED_DATA 0x1000
+
+/** GPS PRN Range */
+#define GPS_SV_PRN_MIN      1
+#define GPS_SV_PRN_MAX      32
+#define GLO_SV_PRN_MIN      65
+#define GLO_SV_PRN_MAX      96
+#define BDS_SV_PRN_MIN      201
+#define BDS_SV_PRN_MAX      235
+#define GAL_SV_PRN_MIN      301
+#define GAL_SV_PRN_MAX      336
 
 typedef enum {
     LOC_RELIABILITY_NOT_SET = 0,
@@ -226,6 +261,13 @@ typedef enum {
     LOC_RELIABILITY_HIGH = 4
 }LocReliability;
 
+typedef struct {
+    uint64_t gps_sv_used_ids_mask;
+    uint64_t glo_sv_used_ids_mask;
+    uint64_t gal_sv_used_ids_mask;
+    uint64_t bds_sv_used_ids_mask;
+} GnssSvUsedInPosition;
+
 /** Represents gps location extended. */
 typedef struct {
     /** set to sizeof(GpsLocationExtended) */
@@ -252,65 +294,49 @@ typedef struct {
     LocReliability  horizontal_reliability;
     /** vertical reliability. */
     LocReliability  vertical_reliability;
+    /*  Horizontal Elliptical Uncertainty (Semi-Major Axis) */
+    float           horUncEllipseSemiMajor;
+    /*  Horizontal Elliptical Uncertainty (Semi-Minor Axis) */
+    float           horUncEllipseSemiMinor;
+    /*    Elliptical Horizontal Uncertainty Azimuth */
+    float           horUncEllipseOrientAzimuth;
+    /** Gnss sv used in position data */
+    GnssSvUsedInPosition gnss_sv_used_ids;
 } GpsLocationExtended;
 
-/** Represents SV status. */
-typedef struct {
-    /** set to sizeof(QcomSvStatus) */
-    size_t          size;
-
-    /** Number of SVs currently visible. */
-    int         num_svs;
-
-    /** Contains an array of SV information. */
-    GpsSvInfo   sv_list[GPS_MAX_SVS];
-
-    /** Represents a bit mask indicating which SVs
-     * have ephemeris data.
-     */
-    uint32_t    ephemeris_mask;
-
-    /** Represents a bit mask indicating which SVs
-     * have almanac data.
-     */
-    uint32_t    almanac_mask;
-
-    /**
-     * Represents a bit mask indicating which GPS SVs
-     * were used for computing the most recent position fix.
-     */
-    uint32_t    gps_used_in_fix_mask;
-
-    /**
-     * Represents a bit mask indicating which GLONASS SVs
-     * were used for computing the most recent position fix.
-     */
-    uint32_t    glo_used_in_fix_mask;
-
-    /**
-     * Represents a bit mask indicating which BDS SVs
-     * were used for computing the most recent position fix.
-     */
-    uint64_t    bds_used_in_fix_mask;
-
-} QcomSvStatus;
-
 enum loc_sess_status {
     LOC_SESS_SUCCESS,
     LOC_SESS_INTERMEDIATE,
     LOC_SESS_FAILURE
 };
 
-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)
+// Nmea sentence types mask
+typedef uint32_t NmeaSentenceTypesMask;
+#define LOC_NMEA_MASK_GGA_V02   ((NmeaSentenceTypesMask)0x00000001) /**<  Enable GGA type  */
+#define LOC_NMEA_MASK_RMC_V02   ((NmeaSentenceTypesMask)0x00000002) /**<  Enable RMC type  */
+#define LOC_NMEA_MASK_GSV_V02   ((NmeaSentenceTypesMask)0x00000004) /**<  Enable GSV type  */
+#define LOC_NMEA_MASK_GSA_V02   ((NmeaSentenceTypesMask)0x00000008) /**<  Enable GSA type  */
+#define LOC_NMEA_MASK_VTG_V02   ((NmeaSentenceTypesMask)0x00000010) /**<  Enable VTG type  */
+#define LOC_NMEA_MASK_PQXFI_V02 ((NmeaSentenceTypesMask)0x00000020) /**<  Enable PQXFI type  */
+#define LOC_NMEA_MASK_PSTIS_V02 ((NmeaSentenceTypesMask)0x00000040) /**<  Enable PSTIS type  */
+#define LOC_NMEA_MASK_GLGSV_V02 ((NmeaSentenceTypesMask)0x00000080) /**<  Enable GLGSV type  */
+#define LOC_NMEA_MASK_GNGSA_V02 ((NmeaSentenceTypesMask)0x00000100) /**<  Enable GNGSA type  */
+#define LOC_NMEA_MASK_GNGNS_V02 ((NmeaSentenceTypesMask)0x00000200) /**<  Enable GNGNS type  */
+#define LOC_NMEA_MASK_GARMC_V02 ((NmeaSentenceTypesMask)0x00000400) /**<  Enable GARMC type  */
+#define LOC_NMEA_MASK_GAGSV_V02 ((NmeaSentenceTypesMask)0x00000800) /**<  Enable GAGSV type  */
+#define LOC_NMEA_MASK_GAGSA_V02 ((NmeaSentenceTypesMask)0x00001000) /**<  Enable GAGSA type  */
+#define LOC_NMEA_MASK_GAVTG_V02 ((NmeaSentenceTypesMask)0x00002000) /**<  Enable GAVTG type  */
+#define LOC_NMEA_MASK_GAGGA_V02 ((NmeaSentenceTypesMask)0x00004000) /**<  Enable GAGGA type  */
+#define LOC_NMEA_MASK_PQGSA_V02 ((NmeaSentenceTypesMask)0x00008000) /**<  Enable PQGSA type  */
+#define LOC_NMEA_MASK_PQGSV_V02 ((NmeaSentenceTypesMask)0x00010000) /**<  Enable PQGSV type  */
+#define LOC_NMEA_ALL_SUPPORTED_MASK  (LOC_NMEA_MASK_GGA_V02 | LOC_NMEA_MASK_RMC_V02 | \
+              LOC_NMEA_MASK_GSV_V02 | LOC_NMEA_MASK_GSA_V02 | LOC_NMEA_MASK_VTG_V02 | \
+        LOC_NMEA_MASK_PQXFI_V02 | LOC_NMEA_MASK_PSTIS_V02 | LOC_NMEA_MASK_GLGSV_V02 | \
+        LOC_NMEA_MASK_GNGSA_V02 | LOC_NMEA_MASK_GNGNS_V02 | LOC_NMEA_MASK_GARMC_V02 | \
+        LOC_NMEA_MASK_GAGSV_V02 | LOC_NMEA_MASK_GAGSA_V02 | LOC_NMEA_MASK_GAVTG_V02 | \
+        LOC_NMEA_MASK_GAGGA_V02 | LOC_NMEA_MASK_PQGSA_V02 | LOC_NMEA_MASK_PQGSV_V02 )
+
+
 
 typedef enum {
   LOC_ENG_IF_REQUEST_SENDER_ID_QUIPC = 0,
diff --git a/gps/loc_api/libloc_api_50001/Android.mk b/gps/loc_api/libloc_api_50001/Android.mk
index 9667b33..800a212 100644
--- a/gps/loc_api/libloc_api_50001/Android.mk
+++ b/gps/loc_api/libloc_api_50001/Android.mk
@@ -92,6 +92,10 @@ LOCAL_CFLAGS += \
     -fno-short-enums \
     -D_ANDROID_ \
 
+ifeq ($(TARGET_BUILD_VARIANT),user)
+   LOCAL_CFLAGS += -DTARGET_BUILD_VARIANT_USER
+endif
+
 ifeq ($(TARGET_USES_QCOM_BSP), true)
 LOCAL_CFLAGS += -DTARGET_USES_QCOM_BSP
 endif
diff --git a/gps/loc_api/libloc_api_50001/LocEngAdapter.cpp b/gps/loc_api/libloc_api_50001/LocEngAdapter.cpp
index 364b2d9..a233424 100644
--- a/gps/loc_api/libloc_api_50001/LocEngAdapter.cpp
+++ b/gps/loc_api/libloc_api_50001/LocEngAdapter.cpp
@@ -81,6 +81,7 @@ LocEngAdapter::LocEngAdapter(LOC_API_ADAPTER_EVENT_MASK_T mask,
 {
     memset(&mFixCriteria, 0, sizeof(mFixCriteria));
     mFixCriteria.mode = LOC_POSITION_MODE_INVALID;
+    clearGnssSvUsedListData();
     LOC_LOGD("LocEngAdapter created");
 }
 
@@ -375,14 +376,14 @@ void LocEngAdapter::reportPosition(UlpLocation &location,
     }
 }
 
-void LocInternalAdapter::reportSv(QcomSvStatus &svStatus,
+void LocInternalAdapter::reportSv(GnssSvStatus &svStatus,
                                   GpsLocationExtended &locationExtended,
                                   void* svExt){
     sendMsg(new LocEngReportSv(mLocEngAdapter, svStatus,
                                locationExtended, svExt));
 }
 
-void LocEngAdapter::reportSv(QcomSvStatus &svStatus,
+void LocEngAdapter::reportSv(GnssSvStatus &svStatus,
                              GpsLocationExtended &locationExtended,
                              void* svExt)
 {
@@ -532,9 +533,8 @@ enum loc_api_adapter_err LocEngAdapter::setTime(GpsUtcTime time,
     if (mSupportsTimeInjection) {
         LOC_LOGD("%s:%d]: Injecting time", __func__, __LINE__);
         result = mLocApi->setTime(time, timeReference, uncertainty);
-    } else {
-        mSupportsTimeInjection = true;
     }
+
     return result;
 }
 
@@ -564,10 +564,10 @@ enum loc_api_adapter_err LocEngAdapter::setXtraVersionCheck(int check)
     return ret;
 }
 
-void LocEngAdapter::reportGpsMeasurementData(GpsData &gpsMeasurementData)
+void LocEngAdapter::reportGnssMeasurementData(GnssData &gnssMeasurementData)
 {
-    sendMsg(new LocEngReportGpsMeasurement(mOwner,
-                                           gpsMeasurementData));
+    sendMsg(new LocEngReportGnssMeasurement(mOwner,
+                                           gnssMeasurementData));
 }
 
 /*
diff --git a/gps/loc_api/libloc_api_50001/LocEngAdapter.h b/gps/loc_api/libloc_api_50001/LocEngAdapter.h
index 8964ede..407b390 100644
--- a/gps/loc_api/libloc_api_50001/LocEngAdapter.h
+++ b/gps/loc_api/libloc_api_50001/LocEngAdapter.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2011-2015, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2011-2016, The Linux Foundation. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
@@ -55,7 +55,7 @@ public:
                                 void* locationExt,
                                 enum loc_sess_status status,
                                 LocPosTechMask loc_technology_mask);
-    virtual void reportSv(QcomSvStatus &svStatus,
+    virtual void reportSv(GnssSvStatus &svStatus,
                           GpsLocationExtended &locationExtended,
                           void* svExt);
     virtual void reportStatus(GpsStatusValue status);
@@ -80,11 +80,14 @@ class LocEngAdapter : public LocAdapterBase {
     unsigned int mPowerVote;
     static const unsigned int POWER_VOTE_RIGHT = 0x20;
     static const unsigned int POWER_VOTE_VALUE = 0x10;
-
+    /** Gnss sv used in position data */
+    GnssSvUsedInPosition mGnssSvIdUsedInPosition;
+    bool mGnssSvIdUsedInPosAvail;
 public:
     bool mSupportsAgpsRequests;
     bool mSupportsPositionInjection;
     bool mSupportsTimeInjection;
+    GnssSystemInfo mGnssInfo;
 
     LocEngAdapter(LOC_API_ADAPTER_EVENT_MASK_T mask,
                   void* owner, ContextBase* context,
@@ -105,8 +108,30 @@ public:
     inline bool hasCPIExtendedCapabilities() {
         return mContext->hasCPIExtendedCapabilities();
     }
+    inline bool hasNativeXtraClient() {
+        return mContext->hasNativeXtraClient();
+    }
     inline const MsgTask* getMsgTask() { return mMsgTask; }
 
+    inline void clearGnssSvUsedListData() {
+        mGnssSvIdUsedInPosAvail = false;
+        memset(&mGnssSvIdUsedInPosition, 0, sizeof (GnssSvUsedInPosition));
+    }
+
+    inline void setGnssSvUsedListData(GnssSvUsedInPosition gnssSvUsedIds) {
+        mGnssSvIdUsedInPosAvail = true;
+        memcpy(&mGnssSvIdUsedInPosition, &gnssSvUsedIds,
+                                    sizeof(GnssSvUsedInPosition));
+    }
+
+    inline GnssSvUsedInPosition getGnssSvUsedListData() {
+        return mGnssSvIdUsedInPosition;
+    }
+
+    inline bool isGnssSvIdUsedInPosAvail() {
+        return mGnssSvIdUsedInPosAvail;
+    }
+
     inline enum loc_api_adapter_err
         startFix()
     {
@@ -187,6 +212,11 @@ public:
         return mLocApi->setSUPLVersion(version);
     }
     inline enum loc_api_adapter_err
+        setNMEATypes (uint32_t typesMask)
+    {
+        return mLocApi->setNMEATypes(typesMask);
+    }
+    inline enum loc_api_adapter_err
         setLPPConfig(uint32_t profile)
     {
         return mLocApi->setLPPConfig(profile);
@@ -222,14 +252,14 @@ public:
                                                   algorithmConfig);
     }
     inline virtual enum loc_api_adapter_err
-        setExtPowerConfig(int isBatteryCharging)
+        setAGLONASSProtocol(unsigned long aGlonassProtocol)
     {
-        return mLocApi->setExtPowerConfig(isBatteryCharging);
+        return mLocApi->setAGLONASSProtocol(aGlonassProtocol);
     }
     inline virtual enum loc_api_adapter_err
-        setAGLONASSProtocol(unsigned long aGlonassProtocol)
+        setLPPeProtocol(unsigned long lppeCP, unsigned long lppeUP)
     {
-        return mLocApi->setAGLONASSProtocol(aGlonassProtocol);
+        return mLocApi->setLPPeProtocol(lppeCP, lppeUP);
     }
     inline virtual int initDataServiceClient()
     {
@@ -269,7 +299,7 @@ public:
                                 void* locationExt,
                                 enum loc_sess_status status,
                                 LocPosTechMask loc_technology_mask);
-    virtual void reportSv(QcomSvStatus &svStatus,
+    virtual void reportSv(GnssSvStatus &svStatus,
                           GpsLocationExtended &locationExtended,
                           void* svExt);
     virtual void reportStatus(GpsStatusValue status);
@@ -284,7 +314,7 @@ public:
     virtual bool requestSuplES(int connHandle);
     virtual bool reportDataCallOpened();
     virtual bool reportDataCallClosed();
-    virtual void reportGpsMeasurementData(GpsData &gpsMeasurementData);
+    virtual void reportGnssMeasurementData(GnssData &gnssMeasurementData);
 
     inline const LocPosMode& getPositionMode() const
     {return mFixCriteria;}
diff --git a/gps/loc_api/libloc_api_50001/loc.cpp b/gps/loc_api/libloc_api_50001/loc.cpp
index 505fc94..f9c43ab 100644
--- a/gps/loc_api/libloc_api_50001/loc.cpp
+++ b/gps/loc_api/libloc_api_50001/loc.cpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2011-2015, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2011-2016, The Linux Foundation. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
@@ -52,9 +52,15 @@ using namespace loc_core;
 //Globals defns
 static gps_location_callback gps_loc_cb = NULL;
 static gps_sv_status_callback gps_sv_cb = NULL;
+static gps_ni_notify_callback gps_ni_cb = NULL;
 
 static void local_loc_cb(UlpLocation* location, void* locExt);
 static void local_sv_cb(GpsSvStatus* sv_status, void* svExt);
+static void local_ni_cb(GpsNiNotification *notification, bool esEnalbed);
+
+GpsNiExtCallbacks sGpsNiExtCallbacks = {
+    local_ni_cb
+};
 
 static const GpsGeofencingInterface* get_geofence_interface(void);
 
@@ -285,6 +291,7 @@ static int loc_init(GpsCallbacks* callbacks)
     }
 
     event = LOC_API_ADAPTER_BIT_PARSED_POSITION_REPORT |
+            LOC_API_ADAPTER_BIT_GNSS_MEASUREMENT |
             LOC_API_ADAPTER_BIT_SATELLITE_REPORT |
             LOC_API_ADAPTER_BIT_LOCATION_SERVER_REQUEST |
             LOC_API_ADAPTER_BIT_ASSISTANCE_DATA_REQUEST |
@@ -304,6 +311,8 @@ static int loc_init(GpsCallbacks* callbacks)
                                     NULL, /* location_ext_parser */
                                     NULL, /* sv_ext_parser */
                                     callbacks->request_utc_time_cb, /* request_utc_time_cb */
+                                    callbacks->set_system_info_cb, /* set_system_info_cb */
+                                    callbacks->gnss_sv_status_cb, /* gnss_sv_status_cb */
                                     };
 
     gps_loc_cb = callbacks->location_cb;
@@ -312,9 +321,10 @@ static int loc_init(GpsCallbacks* callbacks)
     retVal = loc_eng_init(loc_afw_data, &clientCallbacks, event, NULL);
     loc_afw_data.adapter->mSupportsAgpsRequests = !loc_afw_data.adapter->hasAgpsExtendedCapabilities();
     loc_afw_data.adapter->mSupportsPositionInjection = !loc_afw_data.adapter->hasCPIExtendedCapabilities();
-    loc_afw_data.adapter->mSupportsTimeInjection = !loc_afw_data.adapter->hasCPIExtendedCapabilities();
+    loc_afw_data.adapter->mSupportsTimeInjection = !loc_afw_data.adapter->hasCPIExtendedCapabilities()
+                                                   && !loc_afw_data.adapter->hasNativeXtraClient();
     loc_afw_data.adapter->setGpsLockMsg(0);
-    loc_afw_data.adapter->requestUlp(getCarrierCapabilities());
+    loc_afw_data.adapter->requestUlp(ContextBase::getCarrierCapabilities());
     loc_afw_data.adapter->setXtraUserAgent();
 
     if(retVal) {
@@ -538,7 +548,10 @@ SIDE EFFECTS
 static void loc_delete_aiding_data(GpsAidingData f)
 {
     ENTRY_LOG();
+
+#ifndef TARGET_BUILD_VARIANT_USER
     loc_eng_delete_aiding_data(loc_afw_data, f);
+#endif
 
     EXIT_LOG(%s, VOID_RET);
 }
@@ -730,7 +743,7 @@ static int  loc_agps_open_with_apniptype(const char* apn, ApnIpType apnIpType)
             bearerType = AGPS_APN_BEARER_IPV4V6;
             break;
         default:
-            bearerType = AGPS_APN_BEARER_INVALID;
+            bearerType = AGPS_APN_BEARER_IPV4;
             break;
     }
 
@@ -960,7 +973,8 @@ SIDE EFFECTS
 void loc_ni_init(GpsNiCallbacks *callbacks)
 {
     ENTRY_LOG();
-    loc_eng_ni_init(loc_afw_data,(GpsNiExtCallbacks*) callbacks);
+    gps_ni_cb = callbacks->notify_cb;
+    loc_eng_ni_init(loc_afw_data, &sGpsNiExtCallbacks);
     EXIT_LOG(%s, VOID_RET);
 }
 
@@ -1075,3 +1089,10 @@ static void local_sv_cb(GpsSvStatus* sv_status, void* svExt)
     EXIT_LOG(%s, VOID_RET);
 }
 
+static void local_ni_cb(GpsNiNotification *notification, bool esEnalbed)
+{
+    if (NULL != gps_ni_cb) {
+        gps_ni_cb(notification);
+    }
+}
+
diff --git a/gps/loc_api/libloc_api_50001/loc.h b/gps/loc_api/libloc_api_50001/loc.h
index e56fdcf..02ca538 100644
--- a/gps/loc_api/libloc_api_50001/loc.h
+++ b/gps/loc_api/libloc_api_50001/loc.h
@@ -57,6 +57,8 @@ typedef struct {
     loc_ext_parser location_ext_parser;
     loc_ext_parser sv_ext_parser;
     gps_request_utc_time request_utc_time_cb;
+    gnss_set_system_info set_system_info_cb;
+    gnss_sv_status_callback gnss_sv_status_cb;
 } LocCallbacks;
 
 #ifdef __cplusplus
diff --git a/gps/loc_api/libloc_api_50001/loc_eng.cpp b/gps/loc_api/libloc_api_50001/loc_eng.cpp
index 2bd8b89..ba8a10d 100644
--- a/gps/loc_api/libloc_api_50001/loc_eng.cpp
+++ b/gps/loc_api/libloc_api_50001/loc_eng.cpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2009-2015, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2009-2016, The Linux Foundation. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
@@ -90,8 +90,6 @@ using namespace loc_core;
 
 boolean configAlreadyRead = false;
 unsigned int agpsStatus = 0;
-loc_gps_cfg_s_type gps_conf;
-loc_sap_cfg_s_type sap_conf;
 
 /* Parameter spec table */
 static const loc_param_s_type gps_conf_table[] =
@@ -100,8 +98,11 @@ static const loc_param_s_type gps_conf_table[] =
   {"SUPL_VER",                       &gps_conf.SUPL_VER,                       NULL, 'n'},
   {"LPP_PROFILE",                    &gps_conf.LPP_PROFILE,                    NULL, 'n'},
   {"A_GLONASS_POS_PROTOCOL_SELECT",  &gps_conf.A_GLONASS_POS_PROTOCOL_SELECT,  NULL, 'n'},
+  {"LPPE_CP_TECHNOLOGY",             &gps_conf.LPPE_CP_TECHNOLOGY,             NULL, 'n'},
+  {"LPPE_UP_TECHNOLOGY",             &gps_conf.LPPE_UP_TECHNOLOGY,             NULL, 'n'},
   {"AGPS_CERT_WRITABLE_MASK",        &gps_conf.AGPS_CERT_WRITABLE_MASK,        NULL, 'n'},
   {"SUPL_MODE",                      &gps_conf.SUPL_MODE,                      NULL, 'n'},
+  {"SUPL_ES",                        &gps_conf.SUPL_ES,                        NULL, 'n'},
   {"INTERMEDIATE_POS",               &gps_conf.INTERMEDIATE_POS,               NULL, 'n'},
   {"ACCURACY_THRES",                 &gps_conf.ACCURACY_THRES,                 NULL, 'n'},
   {"NMEA_PROVIDER",                  &gps_conf.NMEA_PROVIDER,                  NULL, 'n'},
@@ -143,6 +144,7 @@ static void loc_default_parameters(void)
    gps_conf.GPS_LOCK = 0;
    gps_conf.SUPL_VER = 0x10000;
    gps_conf.SUPL_MODE = 0x3;
+   gps_conf.SUPL_ES = 0;
    gps_conf.CAPABILITIES = 0x7;
    /* LTE Positioning Profile configuration is disable by default*/
    gps_conf.LPP_PROFILE = 0;
@@ -152,6 +154,10 @@ static void loc_default_parameters(void)
    gps_conf.XTRA_VERSION_CHECK=0;
    /*Use emergency PDN by default*/
    gps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL = 1;
+   /* By default no LPPe CP technology is enabled*/
+   gps_conf.LPPE_CP_TECHNOLOGY = 0;
+   /* By default no LPPe UP technology is enabled*/
+   gps_conf.LPPE_UP_TECHNOLOGY = 0;
 
    /*Defaults for sap.conf*/
    sap_conf.GYRO_BIAS_RANDOM_WALK = 0;
@@ -208,6 +214,7 @@ static int loc_eng_get_zpp_handler(loc_eng_data_s_type &loc_eng_data);
 static void deleteAidingData(loc_eng_data_s_type &logEng);
 static AgpsStateMachine*
 getAgpsStateMachine(loc_eng_data_s_type& logEng, AGpsExtType agpsType);
+static void createAgnssNifs(loc_eng_data_s_type& locEng);
 static int dataCallCb(void *cb_data);
 static void update_aiding_data_for_deletion(loc_eng_data_s_type& loc_eng_data) {
     if (loc_eng_data.engine_status != GPS_STATUS_ENGINE_ON &&
@@ -290,6 +297,7 @@ LocEngStopFix::LocEngStopFix(LocEngAdapter* adapter) :
 inline void LocEngStopFix::proc() const
 {
     loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mAdapter->getOwner();
+    mAdapter->clearGnssSvUsedListData();
     loc_eng_stop_handler(*locEng);
 }
 inline void LocEngStopFix::locallog() const
@@ -470,6 +478,29 @@ struct LocEngAGlonassProtocol : public LocMsg {
     }
 };
 
+
+struct LocEngLPPeProtocol : public LocMsg {
+    LocEngAdapter* mAdapter;
+    const unsigned long mLPPeCP;
+    const unsigned long mLPPeUP;
+        inline LocEngLPPeProtocol(LocEngAdapter* adapter,
+                                  unsigned long lppeCP, unsigned long lppeUP) :
+        LocMsg(), mAdapter(adapter), mLPPeCP(lppeCP), mLPPeUP(lppeUP)
+    {
+        locallog();
+    }
+    inline virtual void proc() const {
+        mAdapter->setLPPeProtocol(mLPPeCP, mLPPeUP);
+    }
+    inline  void locallog() const {
+        LOC_LOGV("LPPe CP: 0x%lx LPPe UP: 0x%1x", mLPPeCP, mLPPeUP);
+    }
+    inline virtual void log() const {
+        locallog();
+    }
+};
+
+
 //        case LOC_ENG_MSG_SUPL_VERSION:
 struct LocEngSuplVer : public LocMsg {
     LocEngAdapter* mAdapter;
@@ -500,7 +531,7 @@ struct LocEngSuplMode : public LocMsg {
         locallog();
     }
     inline virtual void proc() const {
-        mUlp->setCapabilities(getCarrierCapabilities());
+        mUlp->setCapabilities(ContextBase::getCarrierCapabilities());
     }
     inline  void locallog() const {
     }
@@ -509,6 +540,31 @@ struct LocEngSuplMode : public LocMsg {
     }
 };
 
+//        case LOC_ENG_MSG_SET_NMEA_TYPE:
+struct LocEngSetNmeaTypes : public LocMsg {
+    LocEngAdapter* mAdapter;
+    uint32_t  nmeaTypesMask;
+    inline LocEngSetNmeaTypes(LocEngAdapter* adapter,
+                                uint32_t typesMask) :
+        LocMsg(), mAdapter(adapter), nmeaTypesMask(typesMask)
+    {
+        locallog();
+    }
+    inline virtual void proc() const {
+        // set the nmea types
+        mAdapter->setNMEATypes(nmeaTypesMask);
+    }
+    inline void locallog() const
+    {
+        LOC_LOGV("LocEngSetNmeaTypes %u\n",nmeaTypesMask);
+    }
+    inline virtual void log() const
+    {
+        locallog();
+    }
+};
+
+
 //        case LOC_ENG_MSG_LPP_CONFIG:
 struct LocEngLppConfig : public LocMsg {
     LocEngAdapter* mAdapter;
@@ -699,29 +755,6 @@ struct LocEngSensorPerfControlConfig : public LocMsg {
     }
 };
 
-//        case LOC_ENG_MSG_EXT_POWER_CONFIG:
-struct LocEngExtPowerConfig : public LocMsg {
-    LocEngAdapter* mAdapter;
-    const int mIsBatteryCharging;
-    inline LocEngExtPowerConfig(LocEngAdapter* adapter,
-                                int isBatteryCharging) :
-        LocMsg(), mAdapter(adapter),
-        mIsBatteryCharging(isBatteryCharging)
-    {
-        locallog();
-    }
-    inline virtual void proc() const {
-        mAdapter->setExtPowerConfig(mIsBatteryCharging);
-    }
-    inline void locallog() const {
-        LOC_LOGV("LocEngExtPowerConfig - isBatteryCharging: %d",
-                 mIsBatteryCharging);
-    }
-    inline virtual void log() const {
-        locallog();
-    }
-};
-
 //        case LOC_ENG_MSG_REPORT_POSITION:
 LocEngReportPosition::LocEngReportPosition(LocAdapterBase* adapter,
                                            UlpLocation &loc,
@@ -771,6 +804,10 @@ void LocEngReportPosition::proc() const {
                         (gps_conf.ACCURACY_THRES != 0) &&
                         (mLocation.gpsLocation.accuracy >
                          gps_conf.ACCURACY_THRES)))) {
+                if (mLocationExtended.flags & GPS_LOCATION_EXTENDED_HAS_GNSS_SV_USED_DATA)
+                {
+                    adapter->setGnssSvUsedListData(mLocationExtended.gnss_sv_used_ids);
+                }
                 locEng->location_cb((UlpLocation*)&(mLocation),
                                     (void*)mLocationExt);
                 reported = true;
@@ -828,7 +865,7 @@ void LocEngReportPosition::send() const {
 
 //        case LOC_ENG_MSG_REPORT_SV:
 LocEngReportSv::LocEngReportSv(LocAdapterBase* adapter,
-                               QcomSvStatus &sv,
+                               GnssSvStatus &sv,
                                GpsLocationExtended &locExtended,
                                void* svExt) :
     LocMsg(), mAdapter(adapter), mSvStatus(sv),
@@ -845,14 +882,57 @@ void LocEngReportSv::proc() const {
 
     if (locEng->mute_session_state != LOC_MUTE_SESS_IN_SESSION)
     {
-        if (locEng->sv_status_cb != NULL) {
-            locEng->sv_status_cb((GpsSvStatus*)&(mSvStatus),
-                                 (void*)mSvExt);
+        GnssSvStatus gnssSvStatus;
+        memcpy(&gnssSvStatus,&mSvStatus,sizeof(GnssSvStatus));
+        if (adapter->isGnssSvIdUsedInPosAvail())
+        {
+            GnssSvUsedInPosition gnssSvIdUsedInPosition =
+                                adapter->getGnssSvUsedListData();
+            int numSv = gnssSvStatus.num_svs;
+            int16_t gnssSvId = 0;
+            uint64_t svUsedIdMask = 0;
+            for (int i=0; i < numSv; i++)
+            {
+                gnssSvId = gnssSvStatus.gnss_sv_list[i].svid;
+                switch(gnssSvStatus.gnss_sv_list[i].constellation) {
+                case GNSS_CONSTELLATION_GPS:
+                    svUsedIdMask = gnssSvIdUsedInPosition.gps_sv_used_ids_mask;
+                    break;
+                case GNSS_CONSTELLATION_GLONASS:
+                    svUsedIdMask = gnssSvIdUsedInPosition.glo_sv_used_ids_mask;
+                    break;
+                case GNSS_CONSTELLATION_BEIDOU:
+                    svUsedIdMask = gnssSvIdUsedInPosition.bds_sv_used_ids_mask;
+                    break;
+                case GNSS_CONSTELLATION_GALILEO:
+                    svUsedIdMask = gnssSvIdUsedInPosition.gal_sv_used_ids_mask;
+                    break;
+                default:
+                    svUsedIdMask = 0;
+                    break;
+                }
+
+                // If SV ID was used in previous position fix, then set USED_IN_FIX
+                // flag, else clear the USED_IN_FIX flag.
+                if (svUsedIdMask & (1 << (gnssSvId - 1)))
+                {
+                    gnssSvStatus.gnss_sv_list[i].flags |= GNSS_SV_FLAGS_USED_IN_FIX;
+                }
+                else
+                {
+                    gnssSvStatus.gnss_sv_list[i].flags &= ~GNSS_SV_FLAGS_USED_IN_FIX;
+                }
+            }
+        }
+
+        if (locEng->gnss_sv_status_cb != NULL) {
+            LOC_LOGE("Calling gnss_sv_status_cb");
+            locEng->gnss_sv_status_cb((GnssSvStatus*)&(gnssSvStatus));
         }
 
         if (locEng->generateNmea)
         {
-            loc_eng_nmea_generate_sv(locEng, mSvStatus, mLocationExtended);
+            loc_eng_nmea_generate_sv(locEng, gnssSvStatus, mLocationExtended);
         }
     }
 }
@@ -902,7 +982,6 @@ void LocEngReportNmea::proc() const {
     struct timeval tv;
     gettimeofday(&tv, (struct timezone *) NULL);
     int64_t now = tv.tv_sec * 1000LL + tv.tv_usec / 1000;
-    CALLBACK_LOG_CALLFLOW("nmea_cb", %d, mLen);
 
     if (locEng->nmea_cb != NULL)
         locEng->nmea_cb(now, mNmea, mLen);
@@ -1090,7 +1169,7 @@ LocEngRequestSuplEs::LocEngRequestSuplEs(void* locEng, int id) :
 }
 void LocEngRequestSuplEs::proc() const {
     loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
-    if (locEng->ds_nif) {
+    if (locEng->ds_nif && gps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL) {
         AgpsStateMachine* sm = locEng->ds_nif;
         DSSubscriber s(sm, mID);
         sm->subscribeRsrc((Subscriber*)&s);
@@ -1214,16 +1293,7 @@ LocEngReqRelWifi::~LocEngReqRelWifi() {
 }
 void LocEngReqRelWifi::proc() const {
     loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
-    if (locEng->wifi_nif) {
-        WIFISubscriber s(locEng->wifi_nif, mSSID, mPassword, mSenderId);
-        if (mIsReq) {
-            locEng->wifi_nif->subscribeRsrc((Subscriber*)&s);
-        } else {
-            locEng->wifi_nif->unsubscribeRsrc((Subscriber*)&s);
-        }
-    } else {
-        locEng->adapter->atlOpenStatus(mSenderId, 0, NULL, -1, mType);
-    }
+    locEng->adapter->atlOpenStatus(mSenderId, 0, NULL, -1, mType);
 }
 inline void LocEngReqRelWifi::locallog() const {
     LOC_LOGV("%s - senderId: %d, ssid: %s, password: %s",
@@ -1377,6 +1447,32 @@ struct LocEngSetCapabilities : public LocMsg {
     }
 };
 
+struct LocEngSetSystemInfo : public LocMsg {
+    loc_eng_data_s_type* mLocEng;
+    inline LocEngSetSystemInfo(loc_eng_data_s_type* locEng) :
+        LocMsg(), mLocEng(locEng)
+    {
+        locallog();
+    }
+    inline virtual void proc() const {
+        if (NULL != mLocEng->set_system_info_cb) {
+            LOC_LOGV("calling set_system_info_cb 0x%x",
+                mLocEng->adapter->mGnssInfo.year_of_hw);
+            mLocEng->set_system_info_cb(&(mLocEng->adapter->mGnssInfo));
+        }
+        else {
+            LOC_LOGV("set_system_info_cb is NULL.\n");
+        }
+    }
+    inline void locallog() const
+    {
+        LOC_LOGV("LocEngSetSystemInfo");
+    }
+    inline virtual void log() const
+    {
+        locallog();
+    }
+};
 //        case LOC_ENG_MSG_LOC_INIT:
 struct LocEngInit : public LocMsg {
     loc_eng_data_s_type* mLocEng;
@@ -1389,6 +1485,7 @@ struct LocEngInit : public LocMsg {
         loc_eng_reinit(*mLocEng);
         // set the capabilities
         mLocEng->adapter->sendMsg(new LocEngSetCapabilities(mLocEng));
+        mLocEng->adapter->sendMsg(new LocEngSetSystemInfo(mLocEng));
     }
     inline void locallog() const
     {
@@ -1405,16 +1502,18 @@ struct LocEngInit : public LocMsg {
 
 //        case LOC_ENG_MSG_ATL_OPEN_SUCCESS:
 struct LocEngAtlOpenSuccess : public LocMsg {
-    AgpsStateMachine* mStateMachine;
+    loc_eng_data_s_type* mLocEng;
+    const AGpsExtType mAgpsType;
     const int mLen;
     char* mAPN;
     const AGpsBearerType mBearerType;
-    inline LocEngAtlOpenSuccess(AgpsStateMachine* statemachine,
+    inline LocEngAtlOpenSuccess(loc_eng_data_s_type* locEng,
+                                const AGpsExtType agpsType,
                                 const char* name,
                                 int len,
                                 AGpsBearerType btype) :
         LocMsg(),
-        mStateMachine(statemachine), mLen(len),
+        mLocEng(locEng), mAgpsType(agpsType), mLen(len),
         mAPN(new char[len+1]), mBearerType(btype)
     {
         memcpy((void*)mAPN, (void*)name, len);
@@ -1426,14 +1525,15 @@ struct LocEngAtlOpenSuccess : public LocMsg {
         delete[] mAPN;
     }
     inline virtual void proc() const {
-        mStateMachine->setBearer(mBearerType);
-        mStateMachine->setAPN(mAPN, mLen);
-        mStateMachine->onRsrcEvent(RSRC_GRANTED);
+        AgpsStateMachine* sm = getAgpsStateMachine(*mLocEng, mAgpsType);
+        sm->setBearer(mBearerType);
+        sm->setAPN(mAPN, mLen);
+        sm->onRsrcEvent(RSRC_GRANTED);
     }
     inline void locallog() const {
         LOC_LOGV("LocEngAtlOpenSuccess agps type: %s\n  apn: %s\n"
                  "  bearer type: %s",
-                 loc_get_agps_type_name(mStateMachine->getType()),
+                 loc_get_agps_type_name(mAgpsType),
                  mAPN,
                  loc_get_agps_bear_name(mBearerType));
     }
@@ -1444,13 +1544,16 @@ struct LocEngAtlOpenSuccess : public LocMsg {
 
 //        case LOC_ENG_MSG_ATL_CLOSED:
 struct LocEngAtlClosed : public LocMsg {
-    AgpsStateMachine* mStateMachine;
-    inline LocEngAtlClosed(AgpsStateMachine* statemachine) :
-        LocMsg(), mStateMachine(statemachine) {
+    loc_eng_data_s_type* mLocEng;
+    const AGpsExtType mAgpsType;
+    inline LocEngAtlClosed(loc_eng_data_s_type* locEng,
+                           const AGpsExtType agpsType) :
+        LocMsg(), mLocEng(locEng), mAgpsType(agpsType) {
         locallog();
     }
     inline virtual void proc() const {
-        mStateMachine->onRsrcEvent(RSRC_RELEASED);
+        AgpsStateMachine* sm = getAgpsStateMachine(*mLocEng, mAgpsType);
+        sm->onRsrcEvent(RSRC_RELEASED);
     }
     inline void locallog() const {
         LOC_LOGV("LocEngAtlClosed");
@@ -1462,13 +1565,16 @@ struct LocEngAtlClosed : public LocMsg {
 
 //        case LOC_ENG_MSG_ATL_OPEN_FAILED:
 struct LocEngAtlOpenFailed : public LocMsg {
-    AgpsStateMachine* mStateMachine;
-    inline LocEngAtlOpenFailed(AgpsStateMachine* statemachine) :
-        LocMsg(), mStateMachine(statemachine) {
+    loc_eng_data_s_type* mLocEng;
+    const AGpsExtType mAgpsType;
+    inline LocEngAtlOpenFailed(loc_eng_data_s_type* locEng,
+                               const AGpsExtType agpsType) :
+        LocMsg(), mLocEng(locEng), mAgpsType(agpsType) {
         locallog();
     }
     inline virtual void proc() const {
-        mStateMachine->onRsrcEvent(RSRC_DENIED);
+        AgpsStateMachine* sm = getAgpsStateMachine(*mLocEng, mAgpsType);
+        sm->onRsrcEvent(RSRC_DENIED);
     }
     inline void locallog() const {
         LOC_LOGV("LocEngAtlOpenFailed");
@@ -1510,22 +1616,17 @@ inline void LocEngUp::log() const {
     locallog();
 }
 
-struct LocEngDataClientInit : public LocMsg {
+struct LocEngAgnssNifInit : public LocMsg {
     loc_eng_data_s_type* mLocEng;
-    inline LocEngDataClientInit(loc_eng_data_s_type* locEng) :
+    inline LocEngAgnssNifInit(loc_eng_data_s_type* locEng) :
         LocMsg(), mLocEng(locEng) {
         locallog();
     }
     virtual void proc() const {
-        loc_eng_data_s_type *locEng = (loc_eng_data_s_type *)mLocEng;
-        if(!locEng->adapter->initDataServiceClient()) {
-            locEng->ds_nif = new DSStateMachine(servicerTypeExt,
-                                               (void *)dataCallCb,
-                                               locEng->adapter);
-        }
+        createAgnssNifs(*mLocEng);
     }
     void locallog() const {
-        LOC_LOGV("LocEngDataClientInit\n");
+        LOC_LOGV("LocEngAgnssNifInit\n");
     }
     virtual void log() const {
         locallog();
@@ -1608,10 +1709,13 @@ struct LocEngGnssConstellationConfig : public LocMsg {
         locallog();
     }
     inline virtual void proc() const {
+        mAdapter->mGnssInfo.size = sizeof(GnssSystemInfo);
         if (mAdapter->gnssConstellationConfig()) {
             LOC_LOGV("Modem supports GNSS measurements\n");
             gps_conf.CAPABILITIES |= GPS_CAPABILITY_MEASUREMENTS;
+            mAdapter->mGnssInfo.year_of_hw = 2016;
         } else {
+            mAdapter->mGnssInfo.year_of_hw = 2015;
             LOC_LOGV("Modem does not support GNSS measurements\n");
         }
     }
@@ -1624,50 +1728,59 @@ struct LocEngGnssConstellationConfig : public LocMsg {
 };
 
 //        case LOC_ENG_MSG_REPORT_GNSS_MEASUREMENT:
-LocEngReportGpsMeasurement::LocEngReportGpsMeasurement(void* locEng,
-                                                       GpsData &gpsData) :
-    LocMsg(), mLocEng(locEng), mGpsData(gpsData)
+LocEngReportGnssMeasurement::LocEngReportGnssMeasurement(void* locEng,
+                                                       GnssData &gnssData) :
+    LocMsg(), mLocEng(locEng), mGnssData(gnssData)
 {
     locallog();
 }
-void LocEngReportGpsMeasurement::proc() const {
+void LocEngReportGnssMeasurement::proc() const {
     loc_eng_data_s_type* locEng = (loc_eng_data_s_type*) mLocEng;
     if (locEng->mute_session_state != LOC_MUTE_SESS_IN_SESSION)
     {
-        if (locEng->gps_measurement_cb != NULL) {
-            locEng->gps_measurement_cb((GpsData*)&(mGpsData));
+        if (locEng->gnss_measurement_cb != NULL) {
+            LOC_LOGV("Calling gnss_measurement_cb");
+            locEng->gnss_measurement_cb((GnssData*)&(mGnssData));
         }
     }
 }
-void LocEngReportGpsMeasurement::locallog() const {
+void LocEngReportGnssMeasurement::locallog() const {
     IF_LOC_LOGV {
         LOC_LOGV("%s:%d]: Received in GPS HAL."
                  "GNSS Measurements count: %d \n",
-                 __func__, __LINE__, mGpsData.measurement_count);
-        for (int i =0; i< mGpsData.measurement_count && i < GPS_MAX_SVS; i++) {
+                 __func__, __LINE__, mGnssData.measurement_count);
+        for (int i =0; i< mGnssData.measurement_count && i < GNSS_MAX_SVS; i++) {
                 LOC_LOGV(" GNSS measurement data in GPS HAL: \n"
-                         " GPS_HAL => Measurement ID | prn | time_offset_ns | state |"
-                         " received_gps_tow_ns| c_n0_dbhz | pseudorange_rate_mps |"
+                         " GPS_HAL => Measurement ID | svid | time_offset_ns | state |"
+                         " c_n0_dbhz | pseudorange_rate_mps |"
                          " pseudorange_rate_uncertainty_mps |"
                          " accumulated_delta_range_state | flags \n"
-                         " GPS_HAL => %d | %d | %f | %d | %lld | %f | %f | %f | %d | %d \n",
+                         " GPS_HAL => %d | %d | %f | %d | %f | %f | %f | %d | %d \n",
                          i,
-                         mGpsData.measurements[i].prn,
-                         mGpsData.measurements[i].time_offset_ns,
-                         mGpsData.measurements[i].state,
-                         mGpsData.measurements[i].received_gps_tow_ns,
-                         mGpsData.measurements[i].c_n0_dbhz,
-                         mGpsData.measurements[i].pseudorange_rate_mps,
-                         mGpsData.measurements[i].pseudorange_rate_uncertainty_mps,
-                         mGpsData.measurements[i].accumulated_delta_range_state,
-                         mGpsData.measurements[i].flags);
+                         mGnssData.measurements[i].svid,
+                         mGnssData.measurements[i].time_offset_ns,
+                         mGnssData.measurements[i].state,
+                         mGnssData.measurements[i].c_n0_dbhz,
+                         mGnssData.measurements[i].pseudorange_rate_mps,
+                         mGnssData.measurements[i].pseudorange_rate_uncertainty_mps,
+                         mGnssData.measurements[i].accumulated_delta_range_state,
+                         mGnssData.measurements[i].flags);
         }
-        LOC_LOGV(" GPS_HAL => Clocks Info: type | time_ns \n"
-                 " GPS_HAL => Clocks Info: %d | %lld", mGpsData.clock.type,
-                 mGpsData.clock.time_ns);
-    }
-}
-inline void LocEngReportGpsMeasurement::log() const {
+        LOC_LOGV(" GPS_HAL => Clocks Info: \n"
+                 " time_ns | full_bias_ns | bias_ns | bias_uncertainty_ns | "
+                 " drift_nsps | drift_uncertainty_nsps | hw_clock_discontinuity_count | flags"
+                 " GPS_HAL => Clocks Info: %lld | %lld | %g | %g | %g | %g | %d | 0x%04x\n",
+            mGnssData.clock.time_ns,
+            mGnssData.clock.full_bias_ns,
+            mGnssData.clock.bias_ns,
+            mGnssData.clock.bias_uncertainty_ns,
+            mGnssData.clock.drift_nsps,
+            mGnssData.clock.drift_uncertainty_nsps,
+            mGnssData.clock.hw_clock_discontinuity_count,
+            mGnssData.clock.flags);
+    }
+}
+inline void LocEngReportGnssMeasurement::log() const {
     locallog();
 }
 
@@ -1684,24 +1797,6 @@ inline void LocEngReportGpsMeasurement::log() const {
   }
 #define INIT_CHECK(ctx, ret) STATE_CHECK(ctx, "instance not initialized", ret)
 
-uint32_t getCarrierCapabilities() {
-    #define carrierMSA (uint32_t)0x2
-    #define carrierMSB (uint32_t)0x1
-    #define gpsConfMSA (uint32_t)0x4
-    #define gpsConfMSB (uint32_t)0x2
-    uint32_t capabilities = gps_conf.CAPABILITIES;
-    if ((gps_conf.SUPL_MODE & carrierMSA) != carrierMSA) {
-        capabilities &= ~gpsConfMSA;
-    }
-    if ((gps_conf.SUPL_MODE & carrierMSB) != carrierMSB) {
-        capabilities &= ~gpsConfMSB;
-    }
-
-    LOC_LOGV("getCarrierCapabilities: CAPABILITIES %x, SUPL_MODE %x, carrier capabilities %x",
-             gps_conf.CAPABILITIES, gps_conf.SUPL_MODE, capabilities);
-    return capabilities;
-}
-
 /*===========================================================================
 FUNCTION    loc_eng_init
 
@@ -1747,6 +1842,8 @@ int loc_eng_init(loc_eng_data_s_type &loc_eng_data, LocCallbacks* callbacks,
     loc_eng_data.acquire_wakelock_cb = callbacks->acquire_wakelock_cb;
     loc_eng_data.release_wakelock_cb = callbacks->release_wakelock_cb;
     loc_eng_data.request_utc_time_cb = callbacks->request_utc_time_cb;
+    loc_eng_data.set_system_info_cb = callbacks->set_system_info_cb;
+    loc_eng_data.gnss_sv_status_cb = callbacks->gnss_sv_status_cb;
     loc_eng_data.location_ext_parser = callbacks->location_ext_parser ?
         callbacks->location_ext_parser : noProc;
     loc_eng_data.sv_ext_parser = callbacks->sv_ext_parser ?
@@ -1762,7 +1859,7 @@ int loc_eng_init(loc_eng_data_s_type &loc_eng_data, LocCallbacks* callbacks,
         event = event ^ LOC_API_ADAPTER_BIT_NMEA_1HZ_REPORT; // unregister for modem NMEA report
         loc_eng_data.generateNmea = true;
     }
-    else
+    else if (gps_conf.NMEA_PROVIDER == NMEA_PROVIDER_MP)
     {
         loc_eng_data.generateNmea = false;
     }
@@ -1771,6 +1868,8 @@ int loc_eng_init(loc_eng_data_s_type &loc_eng_data, LocCallbacks* callbacks,
         new LocEngAdapter(event, &loc_eng_data, context,
                           (LocThread::tCreate)callbacks->create_thread_cb);
 
+    loc_eng_data.adapter->mGnssInfo.size = sizeof(GnssSystemInfo);
+    loc_eng_data.adapter->mGnssInfo.year_of_hw = 2015;
     LOC_LOGD("loc_eng_init created client, id = %p\n",
              loc_eng_data.adapter);
     loc_eng_data.adapter->sendMsg(new LocEngInit(&loc_eng_data));
@@ -1791,6 +1890,15 @@ static int loc_eng_reinit(loc_eng_data_s_type &loc_eng_data)
     adapter->sendMsg(new LocEngSensorControlConfig(adapter, sap_conf.SENSOR_USAGE,
                                                    sap_conf.SENSOR_PROVIDER));
     adapter->sendMsg(new LocEngAGlonassProtocol(adapter, gps_conf.A_GLONASS_POS_PROTOCOL_SELECT));
+    adapter->sendMsg(new LocEngLPPeProtocol(adapter, gps_conf.LPPE_CP_TECHNOLOGY,
+                                            gps_conf.LPPE_UP_TECHNOLOGY));
+
+    if (!loc_eng_data.generateNmea)
+    {
+        NmeaSentenceTypesMask typesMask = LOC_NMEA_ALL_SUPPORTED_MASK;
+        LOC_LOGD("loc_eng_init setting nmea types, mask = %u\n",typesMask);
+        adapter->sendMsg(new LocEngSetNmeaTypes(adapter,typesMask));
+    }
 
     /* Make sure at least one of the sensor property is specified by the user in the gps.conf file. */
     if( sap_conf.GYRO_BIAS_RANDOM_WALK_VALID ||
@@ -1975,7 +2083,6 @@ static int loc_eng_stop_handler(loc_eng_data_s_type &loc_eng_data)
    int ret_val = LOC_API_ADAPTER_ERR_SUCCESS;
 
    if (loc_eng_data.adapter->isInSession()) {
-
        ret_val = loc_eng_data.adapter->stopFix();
        loc_eng_data.adapter->setInSession(FALSE);
    }
@@ -2297,28 +2404,9 @@ void loc_eng_agps_init(loc_eng_data_s_type &loc_eng_data, AGpsExtCallbacks* call
     LocEngAdapter* adapter = loc_eng_data.adapter;
     loc_eng_data.agps_status_cb = callbacks->status_cb;
 
-    loc_eng_data.internet_nif = new AgpsStateMachine(servicerTypeAgps,
-                                                     (void *)loc_eng_data.agps_status_cb,
-                                                     AGPS_TYPE_WWAN_ANY,
-                                                     false);
-    loc_eng_data.wifi_nif = new AgpsStateMachine(servicerTypeAgps,
-                                                 (void *)loc_eng_data.agps_status_cb,
-                                                 AGPS_TYPE_WIFI,
-                                                 true);
-
-    if ((gps_conf.CAPABILITIES & GPS_CAPABILITY_MSA) ||
-        (gps_conf.CAPABILITIES & GPS_CAPABILITY_MSB)) {
-        loc_eng_data.agnss_nif = new AgpsStateMachine(servicerTypeAgps,
-                                                      (void *)loc_eng_data.agps_status_cb,
-                                                      AGPS_TYPE_SUPL,
-                                                      false);
-
+    if (NULL != adapter) {
         if (adapter->mSupportsAgpsRequests) {
-            if(gps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL) {
-                loc_eng_data.adapter->sendMsg(new LocEngDataClientInit(&loc_eng_data));
-            }
-            loc_eng_dmn_conn_loc_api_server_launch(callbacks->create_thread_cb,
-                                                   NULL, NULL, &loc_eng_data);
+            adapter->sendMsg(new LocEngAgnssNifInit(&loc_eng_data));
         }
         loc_eng_agps_reinit(loc_eng_data);
     }
@@ -2334,23 +2422,55 @@ static void deleteAidingData(loc_eng_data_s_type &logEng) {
     }
 }
 
+// must be called under msg handler context
+static void createAgnssNifs(loc_eng_data_s_type& locEng) {
+    bool agpsCapable = ((gps_conf.CAPABILITIES & GPS_CAPABILITY_MSA) ||
+                        (gps_conf.CAPABILITIES & GPS_CAPABILITY_MSB));
+    LocEngAdapter* adapter = locEng.adapter;
+    if (NULL != adapter && adapter->mSupportsAgpsRequests) {
+        if (NULL == locEng.internet_nif) {
+            locEng.internet_nif= new AgpsStateMachine(servicerTypeAgps,
+                                                       (void *)locEng.agps_status_cb,
+                                                       AGPS_TYPE_WWAN_ANY,
+                                                       false);
+        }
+        if (agpsCapable) {
+            if (NULL == locEng.agnss_nif) {
+                locEng.agnss_nif = new AgpsStateMachine(servicerTypeAgps,
+                                                         (void *)locEng.agps_status_cb,
+                                                         AGPS_TYPE_SUPL,
+                                                         false);
+            }
+            if (NULL == locEng.ds_nif &&
+                gps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL &&
+                0 == adapter->initDataServiceClient()) {
+                locEng.ds_nif = new DSStateMachine(servicerTypeExt,
+                                                     (void *)dataCallCb,
+                                                     locEng.adapter);
+            }
+        }
+    }
+}
+
+// must be called under msg handler context
 static AgpsStateMachine*
 getAgpsStateMachine(loc_eng_data_s_type &locEng, AGpsExtType agpsType) {
     AgpsStateMachine* stateMachine;
     switch (agpsType) {
-    case AGPS_TYPE_WIFI: {
-        stateMachine = locEng.wifi_nif;
-        break;
-    }
     case AGPS_TYPE_INVALID:
     case AGPS_TYPE_SUPL: {
         stateMachine = locEng.agnss_nif;
         break;
     }
     case AGPS_TYPE_SUPL_ES: {
-        locEng.ds_nif ?
-            stateMachine = locEng.ds_nif:
+        if (gps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL) {
+            if (NULL == locEng.ds_nif) {
+                createAgnssNifs(locEng);
+            }
+            stateMachine = locEng.ds_nif;
+        } else {
             stateMachine = locEng.agnss_nif;
+        }
         break;
     }
     default:
@@ -2392,10 +2512,9 @@ int loc_eng_agps_open(loc_eng_data_s_type &loc_eng_data, AGpsExtType agpsType,
     LOC_LOGD("loc_eng_agps_open APN name = [%s]", apn);
 
     int apn_len = smaller_of(strlen (apn), MAX_APN_LEN);
-    AgpsStateMachine* sm = getAgpsStateMachine(loc_eng_data, agpsType);
-
     loc_eng_data.adapter->sendMsg(
-        new LocEngAtlOpenSuccess(sm, apn, apn_len, bearerType));
+        new LocEngAtlOpenSuccess(&loc_eng_data, agpsType,
+                                 apn, apn_len, bearerType));
 
     EXIT_LOG(%d, 0);
     return 0;
@@ -2424,8 +2543,8 @@ int loc_eng_agps_closed(loc_eng_data_s_type &loc_eng_data, AGpsExtType agpsType)
     INIT_CHECK(loc_eng_data.adapter && loc_eng_data.agps_status_cb,
                return -1);
 
-    AgpsStateMachine* sm = getAgpsStateMachine(loc_eng_data, agpsType);
-    loc_eng_data.adapter->sendMsg(new LocEngAtlClosed(sm));
+    loc_eng_data.adapter->sendMsg(new LocEngAtlClosed(&loc_eng_data,
+                                                      agpsType));
 
     EXIT_LOG(%d, 0);
     return 0;
@@ -2454,8 +2573,8 @@ int loc_eng_agps_open_failed(loc_eng_data_s_type &loc_eng_data, AGpsExtType agps
     INIT_CHECK(loc_eng_data.adapter && loc_eng_data.agps_status_cb,
                return -1);
 
-    AgpsStateMachine* sm = getAgpsStateMachine(loc_eng_data, agpsType);
-    loc_eng_data.adapter->sendMsg(new LocEngAtlOpenFailed(sm));
+    loc_eng_data.adapter->sendMsg(new LocEngAtlOpenFailed(&loc_eng_data,
+                                                          agpsType));
 
     EXIT_LOG(%d, 0);
     return 0;
@@ -2731,12 +2850,20 @@ void loc_eng_configuration_update (loc_eng_data_s_type &loc_eng_data,
             if (gps_conf_tmp.SUPL_MODE != gps_conf.SUPL_MODE) {
                 adapter->sendMsg(new LocEngSuplMode(adapter->getUlpProxy()));
             }
+            // we always update lock mask, this is because if this is dsds device, we would not
+            // know if modem has switched dds, if so, lock mask may also need to be updated.
+            // if we have power vote, HAL is on, lock mask 0; else gps_conf.GPS_LOCK.
+            adapter->setGpsLockMsg(adapter->getPowerVote() ? 0 : gps_conf.GPS_LOCK);
         }
 
         gps_conf_tmp.SUPL_VER = gps_conf.SUPL_VER;
         gps_conf_tmp.LPP_PROFILE = gps_conf.LPP_PROFILE;
         gps_conf_tmp.A_GLONASS_POS_PROTOCOL_SELECT = gps_conf.A_GLONASS_POS_PROTOCOL_SELECT;
+        gps_conf_tmp.SUPL_MODE = gps_conf.SUPL_MODE;
+        gps_conf_tmp.SUPL_ES = gps_conf.SUPL_ES;
         gps_conf_tmp.GPS_LOCK = gps_conf.GPS_LOCK;
+        gps_conf_tmp.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL =
+                                            gps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL;
         gps_conf = gps_conf_tmp;
     }
 
@@ -2857,8 +2984,9 @@ void loc_eng_handle_engine_up(loc_eng_data_s_type &loc_eng_data)
     if (loc_eng_data.adapter->isInSession()) {
         // This sets the copy in adapter to modem
         loc_eng_data.adapter->setInSession(false);
-        loc_eng_data.adapter->sendMsg(new LocEngStartFix(loc_eng_data.adapter));
+        loc_eng_start_handler(loc_eng_data);
     }
+
     EXIT_LOG(%s, VOID_RET);
 }
 
@@ -2942,8 +3070,8 @@ int loc_eng_gps_measurement_init(loc_eng_data_s_type &loc_eng_data,
 {
     ENTRY_LOG_CALLFLOW();
 
-    STATE_CHECK((NULL == loc_eng_data.gps_measurement_cb),
-                "gps measurement already initialized",
+    STATE_CHECK((NULL == loc_eng_data.gnss_measurement_cb),
+                "gnss measurement already initialized",
                 return GPS_MEASUREMENT_ERROR_ALREADY_INIT);
     STATE_CHECK((callbacks != NULL),
                 "callbacks can not be NULL",
@@ -2959,7 +3087,7 @@ int loc_eng_gps_measurement_init(loc_eng_data_s_type &loc_eng_data,
                                                         event,
                                                         LOC_REGISTRATION_MASK_ENABLED));
     // set up the callback
-    loc_eng_data.gps_measurement_cb = callbacks->measurement_callback;
+    loc_eng_data.gnss_measurement_cb = callbacks->gnss_measurement_callback;
     LOC_LOGD ("%s, event masks updated successfully", __func__);
 
     return GPS_MEASUREMENT_OPERATION_SUCCESS;
@@ -2994,6 +3122,6 @@ void loc_eng_gps_measurement_close(loc_eng_data_s_type &loc_eng_data)
                                                           event,
                                                           LOC_REGISTRATION_MASK_DISABLED));
     // set up the callback
-    loc_eng_data.gps_measurement_cb = NULL;
+    loc_eng_data.gnss_measurement_cb = NULL;
     EXIT_LOG(%d, 0);
 }
diff --git a/gps/loc_api/libloc_api_50001/loc_eng.h b/gps/loc_api/libloc_api_50001/loc_eng.h
index a203e6b..3e52709 100644
--- a/gps/loc_api/libloc_api_50001/loc_eng.h
+++ b/gps/loc_api/libloc_api_50001/loc_eng.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2009-2014, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2009-2014, 2016 The Linux Foundation. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
@@ -67,7 +67,8 @@ typedef unsigned char boolean;
 #define FAILURE                 FALSE
 #define INVALID_ATL_CONNECTION_HANDLE -1
 
-#define MAX_XTRA_SERVER_URL_LENGTH 256
+#define gps_conf ContextBase::mGps_conf
+#define sap_conf ContextBase::mSap_conf
 
 enum loc_nmea_provider_e_type {
     NMEA_PROVIDER_AP = 0, // Application Processor Provider of NMEA
@@ -89,12 +90,14 @@ typedef struct loc_eng_data_s
     loc_sv_status_cb_ext           sv_status_cb;
     agps_status_extended           agps_status_cb;
     gps_nmea_callback              nmea_cb;
-    gps_ni_notify_callback         ni_notify_cb;
+    loc_ni_notify_callback         ni_notify_cb;
     gps_set_capabilities           set_capabilities_cb;
     gps_acquire_wakelock           acquire_wakelock_cb;
     gps_release_wakelock           release_wakelock_cb;
     gps_request_utc_time           request_utc_time_cb;
-    gps_measurement_callback       gps_measurement_cb;
+    gnss_set_system_info           set_system_info_cb;
+    gnss_sv_status_callback        gnss_sv_status_cb;
+    gnss_measurement_callback      gnss_measurement_cb;
     boolean                        intermediateFix;
     AGpsStatusValue                agps_status;
     loc_eng_xtra_data_s_type       xtra_module_data;
@@ -103,7 +106,6 @@ typedef struct loc_eng_data_s
     // AGPS state machines
     AgpsStateMachine*              agnss_nif;
     AgpsStateMachine*              internet_nif;
-    AgpsStateMachine*              wifi_nif;
     //State machine for Data Services
     AgpsStateMachine*              ds_nif;
 
@@ -119,7 +121,8 @@ typedef struct loc_eng_data_s
 
     // For nmea generation
     boolean generateNmea;
-    uint32_t sv_used_mask;
+    uint32_t gps_used_mask;
+    uint32_t glo_used_mask;
     float hdop;
     float pdop;
     float vdop;
@@ -139,67 +142,6 @@ typedef struct loc_eng_data_s
     loc_ext_parser sv_ext_parser;
 } loc_eng_data_s_type;
 
-/* GPS.conf support */
-/* NOTE: the implementaiton of the parser casts number
-   fields to 32 bit. To ensure all 'n' fields working,
-   they must all be 32 bit fields. */
-typedef struct loc_gps_cfg_s
-{
-    uint32_t       INTERMEDIATE_POS;
-    uint32_t       ACCURACY_THRES;
-    uint32_t       SUPL_VER;
-    uint32_t       SUPL_MODE;
-    uint32_t       CAPABILITIES;
-    uint32_t       LPP_PROFILE;
-    uint32_t       XTRA_VERSION_CHECK;
-    char        XTRA_SERVER_1[MAX_XTRA_SERVER_URL_LENGTH];
-    char        XTRA_SERVER_2[MAX_XTRA_SERVER_URL_LENGTH];
-    char        XTRA_SERVER_3[MAX_XTRA_SERVER_URL_LENGTH];
-    uint32_t       USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL;
-    uint32_t       NMEA_PROVIDER;
-    uint32_t       GPS_LOCK;
-    uint32_t       A_GLONASS_POS_PROTOCOL_SELECT;
-    uint32_t       AGPS_CERT_WRITABLE_MASK;
-} loc_gps_cfg_s_type;
-
-/* NOTE: the implementaiton of the parser casts number
-   fields to 32 bit. To ensure all 'n' fields working,
-   they must all be 32 bit fields. */
-/* Meanwhile, *_valid fields are 8 bit fields, and 'f'
-   fields are double. Rigid as they are, it is the
-   the status quo, until the parsing mechanism is
-   change, that is. */
-typedef struct
-{
-    uint8_t        GYRO_BIAS_RANDOM_WALK_VALID;
-    double         GYRO_BIAS_RANDOM_WALK;
-    uint32_t       SENSOR_ACCEL_BATCHES_PER_SEC;
-    uint32_t       SENSOR_ACCEL_SAMPLES_PER_BATCH;
-    uint32_t       SENSOR_GYRO_BATCHES_PER_SEC;
-    uint32_t       SENSOR_GYRO_SAMPLES_PER_BATCH;
-    uint32_t       SENSOR_ACCEL_BATCHES_PER_SEC_HIGH;
-    uint32_t       SENSOR_ACCEL_SAMPLES_PER_BATCH_HIGH;
-    uint32_t       SENSOR_GYRO_BATCHES_PER_SEC_HIGH;
-    uint32_t       SENSOR_GYRO_SAMPLES_PER_BATCH_HIGH;
-    uint32_t       SENSOR_CONTROL_MODE;
-    uint32_t       SENSOR_USAGE;
-    uint32_t       SENSOR_ALGORITHM_CONFIG_MASK;
-    uint8_t        ACCEL_RANDOM_WALK_SPECTRAL_DENSITY_VALID;
-    double         ACCEL_RANDOM_WALK_SPECTRAL_DENSITY;
-    uint8_t        ANGLE_RANDOM_WALK_SPECTRAL_DENSITY_VALID;
-    double         ANGLE_RANDOM_WALK_SPECTRAL_DENSITY;
-    uint8_t        RATE_RANDOM_WALK_SPECTRAL_DENSITY_VALID;
-    double         RATE_RANDOM_WALK_SPECTRAL_DENSITY;
-    uint8_t        VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY_VALID;
-    double         VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY;
-    uint32_t       SENSOR_PROVIDER;
-} loc_sap_cfg_s_type;
-
-extern loc_gps_cfg_s_type gps_conf;
-extern loc_sap_cfg_s_type sap_conf;
-
-
-uint32_t getCarrierCapabilities();
 
 //loc_eng functions
 int  loc_eng_init(loc_eng_data_s_type &loc_eng_data,
diff --git a/gps/loc_api/libloc_api_50001/loc_eng_msg.h b/gps/loc_api/libloc_api_50001/loc_eng_msg.h
index 73a71c0..435ffbb 100644
--- a/gps/loc_api/libloc_api_50001/loc_eng_msg.h
+++ b/gps/loc_api/libloc_api_50001/loc_eng_msg.h
@@ -105,11 +105,11 @@ struct LocEngReportPosition : public LocMsg {
 
 struct LocEngReportSv : public LocMsg {
     LocAdapterBase* mAdapter;
-    const QcomSvStatus mSvStatus;
+    const GnssSvStatus mSvStatus;
     const GpsLocationExtended mLocationExtended;
     const void* mSvExt;
     LocEngReportSv(LocAdapterBase* adapter,
-                   QcomSvStatus &sv,
+                   GnssSvStatus &sv,
                    GpsLocationExtended &locExtended,
                    void* svExtended);
     virtual void proc() const;
@@ -289,11 +289,11 @@ struct LocEngGetZpp : public LocMsg {
     void send() const;
 };
 
-struct LocEngReportGpsMeasurement : public LocMsg {
+struct LocEngReportGnssMeasurement : public LocMsg {
     void* mLocEng;
-    const GpsData mGpsData;
-    LocEngReportGpsMeasurement(void* locEng,
-                               GpsData &gpsData);
+    const GnssData mGnssData;
+    LocEngReportGnssMeasurement(void* locEng,
+                               GnssData &gnssData);
     virtual void proc() const;
     void locallog() const;
     virtual void log() const;
diff --git a/gps/loc_api/libloc_api_50001/loc_eng_ni.cpp b/gps/loc_api/libloc_api_50001/loc_eng_ni.cpp
index 4597b98..d79e635 100644
--- a/gps/loc_api/libloc_api_50001/loc_eng_ni.cpp
+++ b/gps/loc_api/libloc_api_50001/loc_eng_ni.cpp
@@ -189,7 +189,7 @@ void loc_eng_ni_request_handler(loc_eng_data_s_type &loc_eng_data,
         }
 
         CALLBACK_LOG_CALLFLOW("ni_notify_cb - id", %d, notif->notification_id);
-        loc_eng_data.ni_notify_cb((GpsNiNotification*)notif);
+        loc_eng_data.ni_notify_cb((GpsNiNotification*)notif, gps_conf.SUPL_ES != 0);
     }
     EXIT_LOG(%s, VOID_RET);
 }
diff --git a/gps/loc_api/libloc_api_50001/loc_eng_nmea.cpp b/gps/loc_api/libloc_api_50001/loc_eng_nmea.cpp
index d1073b5..c38d0a1 100644
--- a/gps/loc_api/libloc_api_50001/loc_eng_nmea.cpp
+++ b/gps/loc_api/libloc_api_50001/loc_eng_nmea.cpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2012, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2012, 2016, The Linux Foundation. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
@@ -29,10 +29,6 @@
 
 #define LOG_NDDEBUG 0
 #define LOG_TAG "LocSvc_eng_nmea"
-#define GPS_PRN_START 1
-#define GPS_PRN_END   32
-#define GLONASS_PRN_START 65
-#define GLONASS_PRN_END   96
 #include <loc_eng.h>
 #include <loc_eng_nmea.h>
 #include <math.h>
@@ -59,7 +55,6 @@ void loc_eng_nmea_send(char *pNmea, int length, loc_eng_data_s_type *loc_eng_dat
     struct timeval tv;
     gettimeofday(&tv, (struct timezone *) NULL);
     int64_t now = tv.tv_sec * 1000LL + tv.tv_usec / 1000;
-    CALLBACK_LOG_CALLFLOW("nmea_cb", %p, pNmea);
     if (loc_eng_data_p->nmea_cb != NULL)
         loc_eng_data_p->nmea_cb(now, pNmea, length);
     LOC_LOGD("NMEA <%s", pNmea);
@@ -93,8 +88,12 @@ int loc_eng_nmea_put_checksum(char *pNmea, int maxSize)
         length++;
     }
 
+    // length now contains nmea sentence string length not including $ sign.
     int checksumLength = snprintf(pNmea,(maxSize-length-1),"*%02X\r\n", checksum);
-    return (length + checksumLength);
+
+    // total length of nmea sentence is length of nmea sentence inc $ sign plus
+    // length of checksum (+1 is to cover the $ character in the length).
+    return (length + checksumLength + 1);
 }
 
 /*===========================================================================
@@ -102,6 +101,12 @@ FUNCTION    loc_eng_nmea_generate_pos
 
 DESCRIPTION
    Generate NMEA sentences generated based on position report
+   Currently below sentences are generated within this function:
+   - $GPGSA : GPS DOP and active SVs
+   - $GNGSA : GLONASS DOP and active SVs
+   - $GPVTG : Track made good and ground speed
+   - $GPRMC : Recommended minimum navigation information
+   - $GPGGA : Time, position and fix related data
 
 DEPENDENCIES
    NONE
@@ -136,6 +141,7 @@ void loc_eng_nmea_generate_pos(loc_eng_data_s_type *loc_eng_data_p,
     int utcHours = pTm->tm_hour;
     int utcMinutes = pTm->tm_min;
     int utcSeconds = pTm->tm_sec;
+    int utcMSeconds = (location.gpsLocation.timestamp)%1000;
 
     if (generate_nmea) {
         // ------------------
@@ -144,7 +150,7 @@ void loc_eng_nmea_generate_pos(loc_eng_data_s_type *loc_eng_data_p,
 
         uint32_t svUsedCount = 0;
         uint32_t svUsedList[32] = {0};
-        uint32_t mask = loc_eng_data_p->sv_used_mask;
+        uint32_t mask = loc_eng_data_p->gps_used_mask;
         for (uint8_t i = 1; mask > 0 && svUsedCount < 32; i++)
         {
             if (mask & 1)
@@ -152,7 +158,7 @@ void loc_eng_nmea_generate_pos(loc_eng_data_s_type *loc_eng_data_p,
             mask = mask >> 1;
         }
         // clear the cache so they can't be used again
-        loc_eng_data_p->sv_used_mask = 0;
+        loc_eng_data_p->gps_used_mask = 0;
 
         char fixType;
         if (svUsedCount == 0)
@@ -211,6 +217,99 @@ void loc_eng_nmea_generate_pos(loc_eng_data_s_type *loc_eng_data_p,
         loc_eng_nmea_send(sentence, length, loc_eng_data_p);
 
         // ------------------
+        // ------$GNGSA------
+        // ------------------
+        uint32_t gloUsedCount = 0;
+        uint32_t gloUsedList[32] = {0};
+
+        // Reset locals for GNGSA sentence generation
+        pMarker = sentence;
+        lengthRemaining = sizeof(sentence);
+        mask = loc_eng_data_p->glo_used_mask;
+        fixType = '\0';
+
+        // Parse the glonass sv mask, and fetch glo sv ids
+        // Mask corresponds to the offset.
+        // GLONASS SV ids are from 65-96
+        const int GLONASS_SV_ID_OFFSET = 64;
+        for (uint8_t i = 1; mask > 0 && gloUsedCount < 32; i++)
+        {
+            if (mask & 1)
+                gloUsedList[gloUsedCount++] = i + GLONASS_SV_ID_OFFSET;
+            mask = mask >> 1;
+        }
+        // clear the cache so they can't be used again
+        loc_eng_data_p->glo_used_mask = 0;
+
+        if (gloUsedCount == 0)
+            fixType = '1'; // no fix
+        else if (gloUsedCount <= 3)
+            fixType = '2'; // 2D fix
+        else
+            fixType = '3'; // 3D fix
+
+        // Start printing the sentence
+        // Format: $--GSA,a,x,xx,xx,xx,xx,xx,xx,xx,xx,xx,xx,xx,xx,p.p,h.h,v.v*cc
+        // GNGSA : for glonass SVs
+        // a : Mode  : A : Automatic, allowed to automatically switch 2D/3D
+        // x : Fixtype : 1 (no fix), 2 (2D fix), 3 (3D fix)
+        // xx : 12 SV ID
+        // p.p : Position DOP (Dilution of Precision)
+        // h.h : Horizontal DOP
+        // v.v : Vertical DOP
+        // cc : Checksum value
+        length = snprintf(pMarker, lengthRemaining, "$GNGSA,A,%c,", fixType);
+
+        if (length < 0 || length >= lengthRemaining)
+        {
+            LOC_LOGE("NMEA Error in string formatting");
+            return;
+        }
+        pMarker += length;
+        lengthRemaining -= length;
+
+        // Add first 12 GLONASS satellite IDs
+        for (uint8_t i = 0; i < 12; i++)
+        {
+            if (i < gloUsedCount)
+                length = snprintf(pMarker, lengthRemaining, "%02d,", gloUsedList[i]);
+            else
+                length = snprintf(pMarker, lengthRemaining, ",");
+
+            if (length < 0 || length >= lengthRemaining)
+            {
+                LOC_LOGE("NMEA Error in string formatting");
+                return;
+            }
+            pMarker += length;
+            lengthRemaining -= length;
+        }
+
+        // Add the position/horizontal/vertical DOP values
+        if (locationExtended.flags & GPS_LOCATION_EXTENDED_HAS_DOP)
+        {   // dop is in locationExtended, (QMI)
+            length = snprintf(pMarker, lengthRemaining, "%.1f,%.1f,%.1f",
+                              locationExtended.pdop,
+                              locationExtended.hdop,
+                              locationExtended.vdop);
+        }
+        else if (loc_eng_data_p->pdop > 0 && loc_eng_data_p->hdop > 0 && loc_eng_data_p->vdop > 0)
+        {   // dop was cached from sv report (RPC)
+            length = snprintf(pMarker, lengthRemaining, "%.1f,%.1f,%.1f",
+                              loc_eng_data_p->pdop,
+                              loc_eng_data_p->hdop,
+                              loc_eng_data_p->vdop);
+        }
+        else
+        {   // no dop
+            length = snprintf(pMarker, lengthRemaining, ",,");
+        }
+
+        /* Sentence is ready, add checksum and broadcast */
+        length = loc_eng_nmea_put_checksum(sentence, sizeof(sentence));
+        loc_eng_nmea_send(sentence, length, loc_eng_data_p);
+
+        // ------------------
         // ------$GPVTG------
         // ------------------
 
@@ -281,8 +380,8 @@ void loc_eng_nmea_generate_pos(loc_eng_data_s_type *loc_eng_data_p,
         pMarker = sentence;
         lengthRemaining = sizeof(sentence);
 
-        length = snprintf(pMarker, lengthRemaining, "$GPRMC,%02d%02d%02d,A," ,
-                          utcHours, utcMinutes, utcSeconds);
+        length = snprintf(pMarker, lengthRemaining, "$GPRMC,%02d%02d%02d.%02d,A," ,
+                          utcHours, utcMinutes, utcSeconds,utcMSeconds/10);
 
         if (length < 0 || length >= lengthRemaining)
         {
@@ -434,8 +533,8 @@ void loc_eng_nmea_generate_pos(loc_eng_data_s_type *loc_eng_data_p,
         pMarker = sentence;
         lengthRemaining = sizeof(sentence);
 
-        length = snprintf(pMarker, lengthRemaining, "$GPGGA,%02d%02d%02d," ,
-                          utcHours, utcMinutes, utcSeconds);
+        length = snprintf(pMarker, lengthRemaining, "$GPGGA,%02d%02d%02d.%02d," ,
+                          utcHours, utcMinutes, utcSeconds, utcMSeconds/10);
 
         if (length < 0 || length >= lengthRemaining)
         {
@@ -565,6 +664,10 @@ void loc_eng_nmea_generate_pos(loc_eng_data_s_type *loc_eng_data_p,
         length = loc_eng_nmea_put_checksum(sentence, sizeof(sentence));
         loc_eng_nmea_send(sentence, length, loc_eng_data_p);
 
+        strlcpy(sentence, "$GNGSA,A,1,,,,,,,,,,,,,,,", sizeof(sentence));
+        length = loc_eng_nmea_put_checksum(sentence, sizeof(sentence));
+        loc_eng_nmea_send(sentence, length, loc_eng_data_p);
+
         strlcpy(sentence, "$GPVTG,,T,,M,,N,,K,N", sizeof(sentence));
         length = loc_eng_nmea_put_checksum(sentence, sizeof(sentence));
         loc_eng_nmea_send(sentence, length, loc_eng_data_p);
@@ -604,7 +707,7 @@ SIDE EFFECTS
 
 ===========================================================================*/
 void loc_eng_nmea_generate_sv(loc_eng_data_s_type *loc_eng_data_p,
-                              const QcomSvStatus &svStatus, const GpsLocationExtended &locationExtended)
+                              const GnssSvStatus &svStatus, const GpsLocationExtended &locationExtended)
 {
     ENTRY_LOG();
 
@@ -621,15 +724,27 @@ void loc_eng_nmea_generate_sv(loc_eng_data_s_type *loc_eng_data_p,
 
     //Count GPS SVs for saparating GPS from GLONASS and throw others
 
+    loc_eng_data_p->gps_used_mask = 0;
+    loc_eng_data_p->glo_used_mask = 0;
     for(svNumber=1; svNumber <= svCount; svNumber++) {
-        if( (svStatus.sv_list[svNumber-1].prn >= GPS_PRN_START)&&
-            (svStatus.sv_list[svNumber-1].prn <= GPS_PRN_END) )
+        if (GNSS_CONSTELLATION_GPS == svStatus.gnss_sv_list[svNumber - 1].constellation)
         {
+            // cache the used in fix mask, as it will be needed to send $GPGSA
+            // during the position report
+            if (GNSS_SV_FLAGS_USED_IN_FIX == (svStatus.gnss_sv_list[svNumber - 1].flags & GNSS_SV_FLAGS_USED_IN_FIX))
+            {
+                loc_eng_data_p->gps_used_mask |= (1 << (svStatus.gnss_sv_list[svNumber - 1].svid - 1));
+            }
             gpsCount++;
         }
-        else if( (svStatus.sv_list[svNumber-1].prn >= GLONASS_PRN_START) &&
-                 (svStatus.sv_list[svNumber-1].prn <= GLONASS_PRN_END) )
+        else if (GNSS_CONSTELLATION_GLONASS == svStatus.gnss_sv_list[svNumber - 1].constellation)
         {
+            // cache the used in fix mask, as it will be needed to send $GNGSA
+            // during the position report
+            if (GNSS_SV_FLAGS_USED_IN_FIX == (svStatus.gnss_sv_list[svNumber - 1].flags & GNSS_SV_FLAGS_USED_IN_FIX))
+            {
+                loc_eng_data_p->glo_used_mask |= (1 << (svStatus.gnss_sv_list[svNumber - 1].svid - 1));
+            }
             glnCount++;
         }
     }
@@ -669,13 +784,12 @@ void loc_eng_nmea_generate_sv(loc_eng_data_s_type *loc_eng_data_p,
 
             for (int i=0; (svNumber <= svCount) && (i < 4);  svNumber++)
             {
-                if( (svStatus.sv_list[svNumber-1].prn >= GPS_PRN_START) &&
-                    (svStatus.sv_list[svNumber-1].prn <= GPS_PRN_END) )
+                if (GNSS_CONSTELLATION_GPS == svStatus.gnss_sv_list[svNumber - 1].constellation)
                 {
                     length = snprintf(pMarker, lengthRemaining,",%02d,%02d,%03d,",
-                                  svStatus.sv_list[svNumber-1].prn,
-                                  (int)(0.5 + svStatus.sv_list[svNumber-1].elevation), //float to int
-                                  (int)(0.5 + svStatus.sv_list[svNumber-1].azimuth)); //float to int
+                                      svStatus.gnss_sv_list[svNumber-1].svid,
+                                      (int)(0.5 + svStatus.gnss_sv_list[svNumber-1].elevation), //float to int
+                                      (int)(0.5 + svStatus.gnss_sv_list[svNumber-1].azimuth)); //float to int
 
                     if (length < 0 || length >= lengthRemaining)
                     {
@@ -685,10 +799,10 @@ void loc_eng_nmea_generate_sv(loc_eng_data_s_type *loc_eng_data_p,
                     pMarker += length;
                     lengthRemaining -= length;
 
-                    if (svStatus.sv_list[svNumber-1].snr > 0)
+                    if (svStatus.gnss_sv_list[svNumber-1].c_n0_dbhz > 0)
                     {
                         length = snprintf(pMarker, lengthRemaining,"%02d",
-                                         (int)(0.5 + svStatus.sv_list[svNumber-1].snr)); //float to int
+                                         (int)(0.5 + svStatus.gnss_sv_list[svNumber-1].c_n0_dbhz)); //float to int
 
                         if (length < 0 || length >= lengthRemaining)
                         {
@@ -747,13 +861,13 @@ void loc_eng_nmea_generate_sv(loc_eng_data_s_type *loc_eng_data_p,
 
             for (int i=0; (svNumber <= svCount) && (i < 4);  svNumber++)
             {
-                if( (svStatus.sv_list[svNumber-1].prn >= GLONASS_PRN_START) &&
-                    (svStatus.sv_list[svNumber-1].prn <= GLONASS_PRN_END) )      {
+                if (GNSS_CONSTELLATION_GLONASS == svStatus.gnss_sv_list[svNumber - 1].constellation)
+                {
 
                     length = snprintf(pMarker, lengthRemaining,",%02d,%02d,%03d,",
-                                  svStatus.sv_list[svNumber-1].prn,
-                                  (int)(0.5 + svStatus.sv_list[svNumber-1].elevation), //float to int
-                                  (int)(0.5 + svStatus.sv_list[svNumber-1].azimuth)); //float to int
+                        svStatus.gnss_sv_list[svNumber - 1].svid,
+                        (int)(0.5 + svStatus.gnss_sv_list[svNumber - 1].elevation), //float to int
+                        (int)(0.5 + svStatus.gnss_sv_list[svNumber - 1].azimuth)); //float to int
 
                     if (length < 0 || length >= lengthRemaining)
                     {
@@ -763,10 +877,10 @@ void loc_eng_nmea_generate_sv(loc_eng_data_s_type *loc_eng_data_p,
                     pMarker += length;
                     lengthRemaining -= length;
 
-                    if (svStatus.sv_list[svNumber-1].snr > 0)
+                    if (svStatus.gnss_sv_list[svNumber - 1].c_n0_dbhz > 0)
                     {
                         length = snprintf(pMarker, lengthRemaining,"%02d",
-                                         (int)(0.5 + svStatus.sv_list[svNumber-1].snr)); //float to int
+                            (int)(0.5 + svStatus.gnss_sv_list[svNumber - 1].c_n0_dbhz)); //float to int
 
                         if (length < 0 || length >= lengthRemaining)
                         {
@@ -790,10 +904,6 @@ void loc_eng_nmea_generate_sv(loc_eng_data_s_type *loc_eng_data_p,
 
     }//if
 
-    // cache the used in fix mask, as it will be needed to send $GPGSA
-    // during the position report
-    loc_eng_data_p->sv_used_mask = svStatus.gps_used_in_fix_mask;
-
     // For RPC, the DOP are sent during sv report, so cache them
     // now to be sent during position report.
     // For QMI, the DOP will be in position report.
diff --git a/gps/loc_api/libloc_api_50001/loc_eng_nmea.h b/gps/loc_api/libloc_api_50001/loc_eng_nmea.h
index 2563a8f..066943a 100644
--- a/gps/loc_api/libloc_api_50001/loc_eng_nmea.h
+++ b/gps/loc_api/libloc_api_50001/loc_eng_nmea.h
@@ -37,7 +37,7 @@
 
 void loc_eng_nmea_send(char *pNmea, int length, loc_eng_data_s_type *loc_eng_data_p);
 int loc_eng_nmea_put_checksum(char *pNmea, int maxSize);
-void loc_eng_nmea_generate_sv(loc_eng_data_s_type *loc_eng_data_p, const QcomSvStatus &svStatus, const GpsLocationExtended &locationExtended);
+void loc_eng_nmea_generate_sv(loc_eng_data_s_type *loc_eng_data_p, const GnssSvStatus &svStatus, const GpsLocationExtended &locationExtended);
 void loc_eng_nmea_generate_pos(loc_eng_data_s_type *loc_eng_data_p, const UlpLocation &location, const GpsLocationExtended &locationExtended, unsigned char generate_nmea);
 
 #endif // LOC_ENG_NMEA_H
diff --git a/gps/loc_api/libloc_api_50001/loc_eng_xtra.cpp b/gps/loc_api/libloc_api_50001/loc_eng_xtra.cpp
index 7bb8083..d334e0a 100644
--- a/gps/loc_api/libloc_api_50001/loc_eng_xtra.cpp
+++ b/gps/loc_api/libloc_api_50001/loc_eng_xtra.cpp
@@ -124,6 +124,13 @@ int loc_eng_xtra_init (loc_eng_data_s_type &loc_eng_data,
     loc_eng_xtra_data_s_type *xtra_module_data_ptr;
     ENTRY_LOG();
 
+    if(!loc_eng_data.adapter->mSupportsTimeInjection
+       || loc_eng_data.adapter->hasNativeXtraClient()) {
+        LOC_LOGD("XTRA is already supported. disable it here.\n");
+        EXIT_LOG(%d, 1); // return 1 denote failure
+        return 1;
+    }
+
     if(callbacks == NULL) {
         LOC_LOGE("loc_eng_xtra_init: failed, cb is NULL");
     } else {
diff --git a/gps/utils/LocThread.cpp b/gps/utils/LocThread.cpp
index 19bf101..a7fd1c8 100644
--- a/gps/utils/LocThread.cpp
+++ b/gps/utils/LocThread.cpp
@@ -84,9 +84,7 @@ LocThreadDelegate::LocThreadDelegate(LocThread::tCreate creator,
     if (mThandle) {
         // set thread name
         char lname[16];
-        int len = sizeof(lname) - 1;
-        memcpy(lname, threadName, len);
-        lname[len] = 0;
+        strlcpy(lname, threadName, sizeof(lname));
         // set the thread name here
         pthread_setname_np(mThandle, lname);
 
diff --git a/gps/utils/LocTimer.cpp b/gps/utils/LocTimer.cpp
index 70904b2..4de6b40 100644
--- a/gps/utils/LocTimer.cpp
+++ b/gps/utils/LocTimer.cpp
@@ -505,8 +505,13 @@ int LocTimerDelegate::ranks(LocRankable& rankable) {
     LocTimerDelegate* timer = (LocTimerDelegate*)(&rankable);
     if (timer) {
         // larger time ranks lower!!!
-        // IOW, if input obj has bigger tv_sec, this obj outRanks higher
+        // IOW, if input obj has bigger tv_sec/tv_nsec, this obj outRanks higher
         rank = timer->mFutureTime.tv_sec - mFutureTime.tv_sec;
+        if(0 == rank)
+        {
+            //rank against tv_nsec for msec accuracy
+            rank = (int)(timer->mFutureTime.tv_nsec - mFutureTime.tv_nsec);
+        }
     }
     return rank;
 }
diff --git a/gps/utils/MsgTask.cpp b/gps/utils/MsgTask.cpp
index 6f9d0e9..0e7a3a2 100644
--- a/gps/utils/MsgTask.cpp
+++ b/gps/utils/MsgTask.cpp
@@ -63,9 +63,9 @@ MsgTask::~MsgTask() {
 }
 
 void MsgTask::destroy() {
+    LocThread* thread = mThread;
     msg_q_unblock((void*)mQ);
-    if (mThread) {
-        LocThread* thread = mThread;
+    if (thread) {
         mThread = NULL;
         delete thread;
     } else {
diff --git a/gps/utils/log_util.h b/gps/utils/log_util.h
index ffd5ca9..d27c800 100644
--- a/gps/utils/log_util.h
+++ b/gps/utils/log_util.h
@@ -159,6 +159,12 @@ else if (loc_logger.DEBUG_LEVEL == 0xff) { ALOGV("V/" __VA_ARGS__); }
         }                                                                     \
     } while(0)
 
+#define LOC_LOG_HEAD(tag,fmt) "%s:%d][" tag "] " fmt "\n"
+#define LOC_LOGv(tag,fmt,...) LOC_LOGV(LOC_LOG_HEAD(tag,fmt), __func__, __LINE__, ##__VA_ARGS__)
+#define LOC_LOGw(tag,fmt,...) LOC_LOGW(LOC_LOG_HEAD(tag,fmt), __func__, __LINE__, ##__VA_ARGS__)
+#define LOC_LOGd(tag,fmt,...) LOC_LOGD(LOC_LOG_HEAD(tag,fmt), __func__, __LINE__, ##__VA_ARGS__)
+#define LOC_LOGe(tag,fmt,...) LOC_LOGE(LOC_LOG_HEAD(tag,fmt), __func__, __LINE__, ##__VA_ARGS__)
+
 #define LOG_I(ID, WHAT, SPEC, VAL) LOG_(LOC_LOGI, ID, WHAT, SPEC, VAL)
 #define LOG_V(ID, WHAT, SPEC, VAL) LOG_(LOC_LOGV, ID, WHAT, SPEC, VAL)
 #define LOG_E(ID, WHAT, SPEC, VAL) LOG_(LOC_LOGE, ID, WHAT, SPEC, VAL)
author	Michael Bestas <mkbestas@lineageos.org>	2017-05-04 03:22:47 +0300
committer	Rygebin <kaankulahli@gmail.com>	2017-06-24 09:32:17 +0000
commit	30a0d0c9492bdcc107de0f87207dec7b97ab4456 (patch)
tree	fa2026e95376eaa8baa6f6adba7e9ed04e2c8957
parent	5a4a4ae55a32ee5003a008ffe4a357987c1a418b (diff)