Merge branch 'KK.04.04.02.010.399' into l-pdk

Change-Id: I2452a378d4a4697cec2b023a0e9a9bf3e5f14924

53 files changed, 2477 insertions, 3705 deletions

diff --git a/core/Android.mk b/core/Android.mk
index c8a5fd4..0d1b7c2 100644
--- a/core/Android.mk
+++ b/core/Android.mk
@@ -1,3 +1,7 @@
+ifeq (, $(filter aarch64 arm64, $(TARGET_ARCH)))
+ifneq ($(BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE),)
+ifneq ($(BUILD_TINY_ANDROID),true)
+
 LOCAL_PATH := $(call my-dir)
 
 include $(CLEAR_VARS)
@@ -35,12 +39,17 @@ LOCAL_COPY_HEADERS:= \
     LocAdapterBase.h \
     ContextBase.h \
     LocDualContext.h \
-    IzatProxyBase.h \
+    LBSProxyBase.h \
     UlpProxyBase.h \
     gps_extended_c.h \
     gps_extended.h \
-    loc_core_log.h
+    loc_core_log.h \
+    LocAdapterProxyBase.h
 
 LOCAL_PRELINK_MODULE := false
 
 include $(BUILD_SHARED_LIBRARY)
+
+endif # not BUILD_TINY_ANDROID
+endif # BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE
+endif # not aarch64
diff --git a/core/ContextBase.cpp b/core/ContextBase.cpp
index d632a9b..579daf7 100644
--- a/core/ContextBase.cpp
+++ b/core/ContextBase.cpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2011-2013, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2011-2014, 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
@@ -40,21 +40,22 @@
 
 namespace loc_core {
 
-
-IzatProxyBase* ContextBase::getIzatProxy(const char* libName)
+LBSProxyBase* ContextBase::getLBSProxy(const char* libName)
 {
-    IzatProxyBase* proxy = NULL;
+    LBSProxyBase* proxy = NULL;
+    LOC_LOGD("%s:%d]: getLBSProxy libname: %s\n", __func__, __LINE__, libName);
     void* lib = dlopen(libName, RTLD_NOW);
 
     if ((void*)NULL != lib) {
-        getIzatProxy_t* getter = (getIzatProxy_t*)dlsym(lib, "getIzatProxy");
+        getLBSProxy_t* getter = (getLBSProxy_t*)dlsym(lib, "getLBSProxy");
         if (NULL != getter) {
             proxy = (*getter)();
         }
     }
     if (NULL == proxy) {
-        proxy = new IzatProxyBase();
+        proxy = new LBSProxyBase();
     }
+    LOC_LOGD("%s:%d]: Exiting\n", __func__, __LINE__);
     return proxy;
 }
 
@@ -94,7 +95,7 @@ LocApiBase* ContextBase::createLocApi(LOC_API_ADAPTER_EVENT_MASK_T exMask)
     // locApi could still be NULL at this time
     // we would then create a dummy one
     if (NULL == locApi) {
-        locApi = new LocApiBase(mMsgTask, exMask);
+        locApi = new LocApiBase(mMsgTask, exMask, this);
     }
 
     return locApi;
@@ -103,9 +104,10 @@ LocApiBase* ContextBase::createLocApi(LOC_API_ADAPTER_EVENT_MASK_T exMask)
 ContextBase::ContextBase(const MsgTask* msgTask,
                          LOC_API_ADAPTER_EVENT_MASK_T exMask,
                          const char* libName) :
-    mIzatProxy(getIzatProxy(libName)),
+    mLBSProxy(getLBSProxy(libName)),
     mMsgTask(msgTask),
-    mLocApi(createLocApi(exMask))
+    mLocApi(createLocApi(exMask)),
+    mLocApiProxy(mLocApi->getLocApiProxy())
 {
 }
 
diff --git a/core/ContextBase.h b/core/ContextBase.h
index fc60db4..2adbedd 100644
--- a/core/ContextBase.h
+++ b/core/ContextBase.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2011-2013, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2011-2014, 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,33 +33,36 @@
 #include <ctype.h>
 #include <MsgTask.h>
 #include <LocApiBase.h>
-#include <IzatProxyBase.h>
+#include <LBSProxyBase.h>
 
 namespace loc_core {
 
 class LocAdapterBase;
 
 class ContextBase {
-    static IzatProxyBase* getIzatProxy(const char* libName);
+    static LBSProxyBase* getLBSProxy(const char* libName);
     LocApiBase* createLocApi(LOC_API_ADAPTER_EVENT_MASK_T excludedMask);
 protected:
-    const IzatProxyBase* mIzatProxy;
+    const LBSProxyBase* mLBSProxy;
     const MsgTask* mMsgTask;
     LocApiBase* mLocApi;
-
+    LocApiProxyBase *mLocApiProxy;
 public:
     ContextBase(const MsgTask* msgTask,
                 LOC_API_ADAPTER_EVENT_MASK_T exMask,
                 const char* libName);
-    inline virtual ~ContextBase() { delete mLocApi; delete mIzatProxy; }
+    inline virtual ~ContextBase() { delete mLocApi; delete mLBSProxy; }
 
     inline const MsgTask* getMsgTask() { return mMsgTask; }
     inline LocApiBase* getLocApi() { return mLocApi; }
-    inline bool hasAgpsExt() { return mIzatProxy->hasAgpsExt(); }
+    inline LocApiProxyBase* getLocApiProxy() { return mLocApiProxy; }
+    inline bool hasAgpsExtendedCapabilities() { return mLBSProxy->hasAgpsExtendedCapabilities(); }
+    inline bool hasCPIExtendedCapabilities() { return mLBSProxy->hasCPIExtendedCapabilities(); }
     inline void requestUlp(LocAdapterBase* adapter,
                            unsigned long capabilities) {
-        mIzatProxy->requestUlp(adapter, capabilities);
+        mLBSProxy->requestUlp(adapter, capabilities);
     }
+    inline void sendMsg(const LocMsg *msg) { getMsgTask()->sendMsg(msg); }
 };
 
 } // namespace loc_core
diff --git a/loc_api/libloc_api/gps.c b/core/LBSProxyBase.h
index 36bfcb6..0b7dbdf 100644
--- a/loc_api/libloc_api/gps.c
+++ b/core/LBSProxyBase.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2009,2011 The Linux Foundation. All rights reserved.
+/* Copyright (c) 2013-2014, 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
@@ -9,7 +9,7 @@
  *       copyright notice, this list of conditions and the following
  *       disclaimer in the documentation and/or other materials provided
  *       with the distribution.
- *     * Neither the name of The Linux Foundation nor the names of its
+ *     * Neither the name of The Linux Foundation, nor the names of its
  *       contributors may be used to endorse or promote products derived
  *       from this software without specific prior written permission.
  *
@@ -26,43 +26,38 @@
  * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  */
+#ifndef IZAT_PROXY_BASE_H
+#define IZAT_PROXY_BASE_H
+#include <gps_extended.h>
+#include <MsgTask.h>
+
+namespace loc_core {
+
+class LocApiBase;
+class LocAdapterBase;
+class ContextBase;
+
+class LBSProxyBase {
+    friend class ContextBase;
+    inline virtual LocApiBase*
+        getLocApi(const MsgTask* msgTask,
+                  LOC_API_ADAPTER_EVENT_MASK_T exMask,
+                  ContextBase* context) const {
+        return NULL;
+    }
+protected:
+    inline LBSProxyBase() {}
+public:
+    inline virtual ~LBSProxyBase() {}
+    inline virtual void requestUlp(LocAdapterBase* adapter,
+                                   unsigned long capabilities) const {}
+    inline virtual bool hasAgpsExtendedCapabilities() const { return false; }
+    inline virtual bool hasCPIExtendedCapabilities() const { return false; }
+    virtual void injectFeatureConfig(ContextBase* context) const {}
+};
 
-#include <hardware/gps.h>
-
-#include <stdlib.h>
-
-extern const GpsInterface* get_gps_interface();
-
-const GpsInterface* gps__get_gps_interface(struct gps_device_t* dev)
-{
-    return get_gps_interface();
-}
-
-static int open_gps(const struct hw_module_t* module, char const* name,
-        struct hw_device_t** device)
-{
-    struct gps_device_t *dev = malloc(sizeof(struct gps_device_t));
-    memset(dev, 0, sizeof(*dev));
-
-    dev->common.tag = HARDWARE_DEVICE_TAG;
-    dev->common.version = 0;
-    dev->common.module = (struct hw_module_t*)module;
-    dev->get_gps_interface = gps__get_gps_interface;
-
-    *device = (struct hw_device_t*)dev;
-    return 0;
-}
+typedef LBSProxyBase* (getLBSProxy_t)();
 
-static struct hw_module_methods_t gps_module_methods = {
-    .open = open_gps
-};
+} // namespace loc_core
 
-const struct hw_module_t HAL_MODULE_INFO_SYM = {
-    .tag = HARDWARE_MODULE_TAG,
-    .version_major = 1,
-    .version_minor = 0,
-    .id = GPS_HARDWARE_MODULE_ID,
-    .name = "loc_api GPS Module",
-    .author = "Qualcomm USA, Inc.",
-    .methods = &gps_module_methods,
-};
+#endif // IZAT_PROXY_BASE_H
diff --git a/core/LocAdapterBase.cpp b/core/LocAdapterBase.cpp
index 48d179f..eea8edd 100644
--- a/core/LocAdapterBase.cpp
+++ b/core/LocAdapterBase.cpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2011-2013, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2011-2014, 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,44 +33,36 @@
 #include <LocAdapterBase.h>
 #include <loc_target.h>
 #include <log_util.h>
+#include <LocAdapterProxyBase.h>
 
 namespace loc_core {
 
-struct LocOpenMsg : public LocMsg {
-    LocAdapterBase* mLocAdapter;
-    LocApiBase* mLocApi;
-    inline LocOpenMsg(LocAdapterBase* locAdapter,
-                      LocApiBase* locApi) :
-        LocMsg(), mLocAdapter(locAdapter), mLocApi(locApi)
-    {
-        locallog();
-    }
-    inline virtual void proc() const {
-        mLocApi->addAdapter(mLocAdapter);
-    }
-    inline void locallog() {
-        LOC_LOGV("LocOpen");
-    }
-    inline virtual void log() {
-        locallog();
-    }
-};
-
 // This is the top level class, so the constructor will
 // always gets called. Here we prepare for the default.
 // But if getLocApi(targetEnumType target) is overriden,
 // the right locApi should get created.
 LocAdapterBase::LocAdapterBase(const LOC_API_ADAPTER_EVENT_MASK_T mask,
-                               ContextBase* context) :
+                               ContextBase* context, LocAdapterProxyBase *adapterProxyBase) :
     mEvtMask(mask), mContext(context),
-    mLocApi(context->getLocApi()), mMsgTask(context->getMsgTask())
+    mLocApi(context->getLocApi()), mLocAdapterProxyBase(adapterProxyBase),
+    mMsgTask(context->getMsgTask())
 {
-    sendMsg(new LocOpenMsg(this, mLocApi));
+    mLocApi->addAdapter(this);
 }
 
-void LocAdapterBase::
-    handleEngineDownEvent()
-DEFAULT_IMPL()
+void LocAdapterBase::handleEngineUpEvent()
+{
+    if (mLocAdapterProxyBase) {
+        mLocAdapterProxyBase->handleEngineUpEvent();
+    }
+}
+
+void LocAdapterBase::handleEngineDownEvent()
+{
+    if (mLocAdapterProxyBase) {
+        mLocAdapterProxyBase->handleEngineDownEvent();
+    }
+}
 
 void LocAdapterBase::
     reportPosition(UlpLocation &location,
@@ -136,4 +128,8 @@ DEFAULT_IMPL(false)
 bool LocAdapterBase::
     requestNiNotify(GpsNiNotification &notify, const void* data)
 DEFAULT_IMPL(false)
+
+void LocAdapterBase::
+    shutdown()
+DEFAULT_IMPL()
 } // namespace loc_core
diff --git a/core/LocAdapterBase.h b/core/LocAdapterBase.h
index f279f9f..9348a89 100644
--- a/core/LocAdapterBase.h
+++ b/core/LocAdapterBase.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2011-2013, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2011-2014, 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
@@ -35,21 +35,22 @@
 
 namespace loc_core {
 
+class LocAdapterProxyBase;
+
 class LocAdapterBase {
 protected:
     const LOC_API_ADAPTER_EVENT_MASK_T mEvtMask;
     ContextBase* mContext;
     LocApiBase* mLocApi;
+    LocAdapterProxyBase* mLocAdapterProxyBase;
     const MsgTask* mMsgTask;
 
     inline LocAdapterBase(const MsgTask* msgTask) :
-        mEvtMask(0), mContext(NULL), mLocApi(NULL), mMsgTask(msgTask) {}
-
-    LocAdapterBase(const LOC_API_ADAPTER_EVENT_MASK_T mask,
-                   ContextBase* context);
-    inline virtual ~LocAdapterBase() { mLocApi->removeAdapter(this); }
-
+        mEvtMask(0), mContext(NULL), mLocApi(NULL), mLocAdapterProxyBase(NULL), mMsgTask(msgTask) {}
 public:
+    inline virtual ~LocAdapterBase() { mLocApi->removeAdapter(this); }
+    LocAdapterBase(const LOC_API_ADAPTER_EVENT_MASK_T mask,
+                   ContextBase* context, LocAdapterProxyBase *adapterProxyBase = NULL);
     inline LOC_API_ADAPTER_EVENT_MASK_T
         checkMask(LOC_API_ADAPTER_EVENT_MASK_T mask) const {
         return mEvtMask & mask;
@@ -70,11 +71,12 @@ public:
     // This will be overridden by the individual adapters
     // if necessary.
     inline virtual void setUlpProxy(UlpProxyBase* ulp) {}
-    inline virtual void handleEngineUpEvent() {}
+    virtual void handleEngineUpEvent();
     virtual void handleEngineDownEvent();
     inline virtual void setPositionModeInt(LocPosMode& posMode) {}
     virtual void startFixInt() {}
     virtual void stopFixInt() {}
+    virtual void getZppInt() {}
     virtual void reportPosition(UlpLocation &location,
                                 GpsLocationExtended &locationExtended,
                                 void* locationExt,
@@ -98,6 +100,8 @@ public:
     virtual bool requestNiNotify(GpsNiNotification &notify,
                                  const void* data);
     inline virtual bool isInSession() { return false; }
+    virtual void shutdown();
+    ContextBase* getContext() const { return mContext; }
 };
 
 } // namespace loc_core
diff --git a/loc_api/libloc_api/loc_eng_xtra.h b/core/LocAdapterProxyBase.h
index a72b152..25af10b 100644
--- a/loc_api/libloc_api/loc_eng_xtra.h
+++ b/core/LocAdapterProxyBase.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2009,2011 The Linux Foundation. All rights reserved.
+/* Copyright (c) 2014 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
@@ -9,7 +9,7 @@
  *       copyright notice, this list of conditions and the following
  *       disclaimer in the documentation and/or other materials provided
  *       with the distribution.
- *     * Neither the name of The Linux Foundation nor the names of its
+ *     * Neither the name of The Linux Foundation, nor the names of its
  *       contributors may be used to endorse or promote products derived
  *       from this software without specific prior written permission.
  *
@@ -27,19 +27,33 @@
  *
  */
 
-#ifndef LOC_ENG_XTRA_H
-#define LOC_ENG_XTRA_H
+#ifndef LOC_ADAPTER_PROXY_BASE_H
+#define LOC_ADAPTER_PROXY_BASE_H
 
-#include <hardware/gps.h>
+#include <ContextBase.h>
+#include <gps_extended.h>
 
-extern const GpsXtraInterface sLocEngXTRAInterface;
+namespace loc_core {
 
-// Module data
-typedef struct
-{
-    // loc_eng_ioctl_cb_data_s_type   ioctl_cb_data;
-    gps_xtra_download_request      download_request_cb;
+class LocAdapterProxyBase {
+private:
+    const LocAdapterBase *mLocAdapterBase;
+protected:
+    inline LocAdapterProxyBase(const LOC_API_ADAPTER_EVENT_MASK_T mask,
+                   ContextBase* context):
+                   mLocAdapterBase(new LocAdapterBase(mask, context, this)) {
+    }
+    inline virtual ~LocAdapterProxyBase() {
+        delete mLocAdapterBase;
+    }
+    ContextBase* getContext() const {
+        return mLocAdapterBase->getContext();
+    }
+public:
+    inline virtual void handleEngineUpEvent() {};
+    inline virtual void handleEngineDownEvent() {};
+};
 
-} loc_eng_xtra_data_s_type;
+} // namespace loc_core
 
-#endif // LOC_ENG_XTRA_H
+#endif //LOC_ADAPTER_PROXY_BASE_H
diff --git a/core/LocApiBase.cpp b/core/LocApiBase.cpp
index f50d3e1..90f3653 100644
--- a/core/LocApiBase.cpp
+++ b/core/LocApiBase.cpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2011-2013, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2011-2014, 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,6 +33,7 @@
 #include <LocApiBase.h>
 #include <LocAdapterBase.h>
 #include <log_util.h>
+#include <LocDualContext.h>
 
 namespace loc_core {
 
@@ -103,9 +104,31 @@ struct LocSsrMsg : public LocMsg {
     }
 };
 
+struct LocOpenMsg : public LocMsg {
+    LocApiBase* mLocApi;
+    LOC_API_ADAPTER_EVENT_MASK_T mMask;
+    inline LocOpenMsg(LocApiBase* locApi,
+                      LOC_API_ADAPTER_EVENT_MASK_T mask) :
+        LocMsg(), mLocApi(locApi), mMask(mask)
+    {
+        locallog();
+    }
+    inline virtual void proc() const {
+        mLocApi->open(mMask);
+    }
+    inline void locallog() {
+        LOC_LOGV("%s:%d]: LocOpen Mask: %x\n",
+                 __func__, __LINE__, mMask);
+    }
+    inline virtual void log() {
+        locallog();
+    }
+};
+
 LocApiBase::LocApiBase(const MsgTask* msgTask,
-                       LOC_API_ADAPTER_EVENT_MASK_T excludedMask) :
-    mExcludedMask(excludedMask), mMsgTask(msgTask), mMask(0)
+                       LOC_API_ADAPTER_EVENT_MASK_T excludedMask,
+                       ContextBase* context) :
+    mExcludedMask(excludedMask), mMsgTask(msgTask), mMask(0), mContext(context)
 {
     memset(mLocAdapters, 0, sizeof(mLocAdapters));
 }
@@ -123,7 +146,11 @@ bool LocApiBase::isInSession()
 {
     bool inSession = false;
 
-    TO_ALL_LOCADAPTERS(inSession = mLocAdapters[i]->isInSession());
+    for (int i = 0;
+         !inSession && i < MAX_ADAPTERS && NULL != mLocAdapters[i];
+         i++) {
+        inSession = mLocAdapters[i]->isInSession();
+    }
 
     return inSession;
 }
@@ -133,7 +160,8 @@ void LocApiBase::addAdapter(LocAdapterBase* adapter)
     for (int i = 0; i < MAX_ADAPTERS && mLocAdapters[i] != adapter; i++) {
         if (mLocAdapters[i] == NULL) {
             mLocAdapters[i] = adapter;
-            open(mMask | (adapter->getEvtMask() & ~mExcludedMask));
+            mMsgTask->sendMsg(new LocOpenMsg(this,
+                                             (adapter->getEvtMask())));
             break;
         }
     }
@@ -169,7 +197,7 @@ void LocApiBase::removeAdapter(LocAdapterBase* adapter)
                 close();
             } else {
                 // else we need to remove the bit
-                open(getEvtMask() & ~mExcludedMask);
+                mMsgTask->sendMsg(new LocOpenMsg(this, getEvtMask()));
             }
         }
     }
@@ -180,6 +208,8 @@ void LocApiBase::handleEngineUpEvent()
     // This will take care of renegotiating the loc handle
     mMsgTask->sendMsg(new LocSsrMsg(this));
 
+    LocDualContext::injectFeatureConfig(mContext);
+
     // loop through adapters, and deliver to all adapters.
     TO_ALL_LOCADAPTERS(mLocAdapters[i]->handleEngineUpEvent());
 }
@@ -292,6 +322,12 @@ void LocApiBase::requestNiNotify(GpsNiNotification &notify, const void* data)
     TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->requestNiNotify(notify, data));
 }
 
+void* LocApiBase :: getSibling()
+    DEFAULT_IMPL(NULL)
+
+LocApiProxyBase* LocApiBase :: getLocApiProxy()
+    DEFAULT_IMPL(NULL)
+
 enum loc_api_adapter_err LocApiBase::
    open(LOC_API_ADAPTER_EVENT_MASK_T mask)
 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
@@ -372,7 +408,8 @@ enum loc_api_adapter_err LocApiBase::
 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
 
 enum loc_api_adapter_err LocApiBase::
-    setSensorControlConfig(int sensorUsage)
+    setSensorControlConfig(int sensorUsage,
+                           int sensorProvider)
 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
 
 enum loc_api_adapter_err LocApiBase::
@@ -409,6 +446,18 @@ enum loc_api_adapter_err LocApiBase::
     setAGLONASSProtocol(unsigned long aGlonassProtocol)
 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
 
+enum loc_api_adapter_err LocApiBase::
+   getWwanZppFix(GpsLocation & zppLoc)
+DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
+
+enum loc_api_adapter_err LocApiBase::
+   getBestAvailableZppFix(GpsLocation & zppLoc)
+DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
+
+enum loc_api_adapter_err LocApiBase::
+   getBestAvailableZppFix(GpsLocation & zppLoc, LocPosTechMask & tech_mask)
+DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
+
 int LocApiBase::
     initDataServiceClient()
 DEFAULT_IMPL(-1)
@@ -425,5 +474,11 @@ void LocApiBase::
     closeDataCall()
 DEFAULT_IMPL()
 
+int LocApiBase::
+    setGpsLock(unsigned int lock)
+DEFAULT_IMPL(-1)
 
+int LocApiBase::
+    getGpsLock()
+DEFAULT_IMPL(-1)
 } // namespace loc_core
diff --git a/core/LocApiBase.h b/core/LocApiBase.h
index 87facf1..bef0379 100644
--- a/core/LocApiBase.h
+++ b/core/LocApiBase.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2011-2013, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2011-2014, 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,8 +33,10 @@
 #include <ctype.h>
 #include <gps_extended.h>
 #include <MsgTask.h>
+#include <log_util.h>
 
 namespace loc_core {
+class ContextBase;
 
 int hexcode(char *hexstring, int string_size,
             const char *data, int data_size);
@@ -51,16 +53,25 @@ int decodeAddress(char *addr_string, int string_size,
 #define TO_1ST_HANDLING_ADAPTER(adapters, call)                              \
     for (int i = 0; i <MAX_ADAPTERS && NULL != (adapters)[i] && !(call); i++);
 
-
 class LocAdapterBase;
 struct LocSsrMsg;
+struct LocOpenMsg;
+
+class LocApiProxyBase {
+public:
+    inline LocApiProxyBase() {}
+    inline virtual ~LocApiProxyBase() {}
+    inline virtual void* getSibling2() { return NULL; }
+};
 
 class LocApiBase {
     friend struct LocSsrMsg;
+    //LocOpenMsg calls open() which makes it necessary to declare
+    //it as a friend
+    friend struct LocOpenMsg;
     friend class ContextBase;
-    const LOC_API_ADAPTER_EVENT_MASK_T mExcludedMask;
     const MsgTask* mMsgTask;
-
+    ContextBase *mContext;
     LocAdapterBase* mLocAdapters[MAX_ADAPTERS];
 
 protected:
@@ -68,16 +79,19 @@ protected:
         open(LOC_API_ADAPTER_EVENT_MASK_T mask);
     virtual enum loc_api_adapter_err
         close();
-
     LOC_API_ADAPTER_EVENT_MASK_T getEvtMask();
     LOC_API_ADAPTER_EVENT_MASK_T mMask;
     LocApiBase(const MsgTask* msgTask,
-               LOC_API_ADAPTER_EVENT_MASK_T excludedMask);
+               LOC_API_ADAPTER_EVENT_MASK_T excludedMask,
+               ContextBase* context = NULL);
     inline virtual ~LocApiBase() { close(); }
     bool isInSession();
+    const LOC_API_ADAPTER_EVENT_MASK_T mExcludedMask;
 
 public:
-    inline virtual void* getSibling() { return NULL; }
+    inline void sendMsg(const LocMsg* msg) const {
+        mMsgTask->sendMsg(msg);
+    }
 
     void addAdapter(LocAdapterBase* adapter);
     void removeAdapter(LocAdapterBase* adapter);
@@ -111,6 +125,9 @@ public:
     // downward calls
     // All below functions are to be defined by adapter specific modules:
     // RPC, QMI, etc.  The default implementation is empty.
+
+    virtual void* getSibling();
+    virtual LocApiProxyBase* getLocApiProxy();
     virtual enum loc_api_adapter_err
         startFix(const LocPosMode& posMode);
     virtual enum loc_api_adapter_err
@@ -147,7 +164,7 @@ public:
     virtual enum loc_api_adapter_err
         setLPPConfig(uint32_t profile);
     virtual enum loc_api_adapter_err
-        setSensorControlConfig(int sensorUsage);
+        setSensorControlConfig(int sensorUsage, int sensorProvider);
     virtual enum loc_api_adapter_err
         setSensorProperties(bool gyroBiasVarianceRandomWalk_valid,
                             float gyroBiasVarianceRandomWalk,
@@ -174,16 +191,37 @@ public:
         setExtPowerConfig(int isBatteryCharging);
     virtual enum loc_api_adapter_err
         setAGLONASSProtocol(unsigned long aGlonassProtocol);
+    virtual enum loc_api_adapter_err
+        getWwanZppFix(GpsLocation & zppLoc);
+    virtual enum loc_api_adapter_err
+        getBestAvailableZppFix(GpsLocation & zppLoc);
+    virtual enum loc_api_adapter_err
+        getBestAvailableZppFix(GpsLocation & zppLoc, LocPosTechMask & tech_mask);
     virtual int initDataServiceClient();
     virtual int openAndStartDataCall();
     virtual void stopDataCall();
     virtual void closeDataCall();
 
     inline virtual void setInSession(bool inSession) {}
+
+    /*Values for lock
+      1 = Do not lock any position sessions
+      2 = Lock MI position sessions
+      3 = Lock MT position sessions
+      4 = Lock all position sessions
+     */
+    virtual int setGpsLock(unsigned int lock);
+    /*
+      Returns
+      Current value of GPS Lock on success
+      -1 on failure
+     */
+    virtual int getGpsLock(void);
 };
 
 typedef LocApiBase* (getLocApi_t)(const MsgTask* msgTask,
-                                  LOC_API_ADAPTER_EVENT_MASK_T exMask);
+                                  LOC_API_ADAPTER_EVENT_MASK_T exMask,
+                                  ContextBase *context);
 
 } // namespace loc_core
 
diff --git a/core/LocDualContext.cpp b/core/LocDualContext.cpp
index 381743d..ab15110 100644
--- a/core/LocDualContext.cpp
+++ b/core/LocDualContext.cpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2011-2013, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2011-2014, 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,7 +44,8 @@ LocDualContext::mFgExclMask = 0;
 // excluded events for background clients
 const LOC_API_ADAPTER_EVENT_MASK_T
 LocDualContext::mBgExclMask =
-    (LOC_API_ADAPTER_BIT_SATELLITE_REPORT |
+    (LOC_API_ADAPTER_BIT_PARSED_POSITION_REPORT |
+     LOC_API_ADAPTER_BIT_SATELLITE_REPORT |
      LOC_API_ADAPTER_BIT_NMEA_1HZ_REPORT |
      LOC_API_ADAPTER_BIT_NMEA_POSITION_REPORT |
      LOC_API_ADAPTER_BIT_IOCTL_REPORT |
@@ -54,10 +55,10 @@ LocDualContext::mBgExclMask =
 const MsgTask* LocDualContext::mMsgTask = NULL;
 ContextBase* LocDualContext::mFgContext = NULL;
 ContextBase* LocDualContext::mBgContext = NULL;
-
+ContextBase* LocDualContext::mInjectContext = NULL;
 // the name must be shorter than 15 chars
 const char* LocDualContext::mLocationHalName = "Loc_hal_worker";
-const char* LocDualContext::mIzatLibName = "libizat_core.so";
+const char* LocDualContext::mLBSLibName = "liblbs_core.so";
 
 const MsgTask* LocDualContext::getMsgTask(MsgTask::tCreate tCreator,
                                           const char* name)
@@ -73,6 +74,8 @@ const MsgTask* LocDualContext::getMsgTask(MsgTask::tAssociate tAssociate,
 {
     if (NULL == mMsgTask) {
         mMsgTask = new MsgTask(tAssociate, name);
+    } else if (tAssociate) {
+        mMsgTask->associate(tAssociate);
     }
     return mMsgTask;
 }
@@ -85,6 +88,10 @@ ContextBase* LocDualContext::getLocFgContext(MsgTask::tCreate tCreator,
         mFgContext = new LocDualContext(msgTask,
                                         mFgExclMask);
     }
+    if(NULL == mInjectContext) {
+        mInjectContext = mFgContext;
+        injectFeatureConfig(mInjectContext);
+    }
     return mFgContext;
 }
 
@@ -96,6 +103,11 @@ ContextBase* LocDualContext::getLocFgContext(MsgTask::tAssociate tAssociate,
         mFgContext = new LocDualContext(msgTask,
                                         mFgExclMask);
     }
+    if(NULL == mInjectContext) {
+        LOC_LOGD("%s:%d]: mInjectContext is FgContext", __func__, __LINE__);
+        mInjectContext = mFgContext;
+        injectFeatureConfig(mInjectContext);
+    }
     return mFgContext;
 
 }
@@ -108,6 +120,11 @@ ContextBase* LocDualContext::getLocBgContext(MsgTask::tCreate tCreator,
         mBgContext = new LocDualContext(msgTask,
                                         mBgExclMask);
     }
+    if(NULL == mInjectContext) {
+        LOC_LOGD("%s:%d]: mInjectContext is BgContext", __func__, __LINE__);
+        mInjectContext = mBgContext;
+        injectFeatureConfig(mInjectContext);
+    }
     return mBgContext;
 }
 
@@ -119,12 +136,28 @@ ContextBase* LocDualContext::getLocBgContext(MsgTask::tAssociate tAssociate,
         mBgContext = new LocDualContext(msgTask,
                                         mBgExclMask);
     }
+    if(NULL == mInjectContext) {
+        LOC_LOGD("%s:%d]: mInjectContext is BgContext", __func__, __LINE__);
+        mInjectContext = mBgContext;
+        injectFeatureConfig(mInjectContext);
+    }
     return mBgContext;
 }
 
+void LocDualContext :: injectFeatureConfig(ContextBase *curContext)
+{
+    LOC_LOGD("%s:%d]: Enter", __func__, __LINE__);
+    if(curContext == mInjectContext) {
+        LOC_LOGD("%s:%d]: Calling LBSProxy (%p) to inject feature config",
+                 __func__, __LINE__, ((LocDualContext *)mInjectContext)->mLBSProxy);
+        ((LocDualContext *)mInjectContext)->mLBSProxy->injectFeatureConfig(curContext);
+    }
+    LOC_LOGD("%s:%d]: Exit", __func__, __LINE__);
+}
+
 LocDualContext::LocDualContext(const MsgTask* msgTask,
                                LOC_API_ADAPTER_EVENT_MASK_T exMask) :
-    ContextBase(msgTask, exMask, mIzatLibName)
+    ContextBase(msgTask, exMask, mLBSLibName)
 {
 }
 
diff --git a/core/LocDualContext.h b/core/LocDualContext.h
index e761e76..cdc4df3 100644
--- a/core/LocDualContext.h
+++ b/core/LocDualContext.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2011-2013, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2011-2014, 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
@@ -40,7 +40,7 @@ class LocDualContext : public ContextBase {
     static const MsgTask* mMsgTask;
     static ContextBase* mFgContext;
     static ContextBase* mBgContext;
-
+    static ContextBase* mInjectContext;
     static const MsgTask* getMsgTask(MsgTask::tCreate tCreator,
                                      const char* name);
     static const MsgTask* getMsgTask(MsgTask::tAssociate tAssociate,
@@ -52,7 +52,7 @@ protected:
     inline virtual ~LocDualContext() {}
 
 public:
-    static const char* mIzatLibName;
+    static const char* mLBSLibName;
     static const LOC_API_ADAPTER_EVENT_MASK_T mFgExclMask;
     static const LOC_API_ADAPTER_EVENT_MASK_T mBgExclMask;
     static const char* mLocationHalName;
@@ -65,6 +65,7 @@ public:
                                         const char* name);
     static ContextBase* getLocBgContext(MsgTask::tAssociate tAssociate,
                                         const char* name);
+    static void injectFeatureConfig(ContextBase *context);
 };
 
 }
diff --git a/core/MsgTask.cpp b/core/MsgTask.cpp
index e61ce1c..4db992d 100644
--- a/core/MsgTask.cpp
+++ b/core/MsgTask.cpp
@@ -35,6 +35,7 @@
 #include <msg_q.h>
 #include <log_util.h>
 #include <loc_log.h>
+#include <android_runtime/AndroidRuntime.h>
 
 namespace loc_core {
 
@@ -68,6 +69,21 @@ MsgTask::~MsgTask() {
     msg_q_unblock((void*)mQ);
 }
 
+void MsgTask::associate(tAssociate tAssociator) const {
+    struct LocAssociateMsg : public LocMsg {
+        tAssociate mAssociator;
+        inline LocAssociateMsg(tAssociate associator) :
+            LocMsg(), mAssociator(associator) {}
+        inline virtual void proc() const {
+            if (mAssociator) {
+                LOC_LOGD("MsgTask::associate");
+                mAssociator();
+            }
+        }
+    };
+    sendMsg(new LocAssociateMsg(tAssociator));
+}
+
 void MsgTask::createPThread(const char* threadName) {
     pthread_attr_t attr;
     pthread_attr_init(&attr);
diff --git a/core/MsgTask.h b/core/MsgTask.h
index d09de73..d50bb31 100644
--- a/core/MsgTask.h
+++ b/core/MsgTask.h
@@ -52,6 +52,7 @@ public:
     MsgTask(tAssociate tAssociator, const char* threadName);
     ~MsgTask();
     void sendMsg(const LocMsg* msg) const;
+    void associate(tAssociate tAssociator) const;
 
 private:
     const void* mQ;
diff --git a/core/UlpProxyBase.h b/core/UlpProxyBase.h
index 02ba167..b9a8224 100644
--- a/core/UlpProxyBase.h
+++ b/core/UlpProxyBase.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2013, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2013-2014, 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
@@ -37,11 +37,20 @@ class LocAdapterBase;
 
 class UlpProxyBase {
 public:
-    inline UlpProxyBase() {}
+    LocPosMode mPosMode;
+    bool mFixSet;
+    inline UlpProxyBase() {
+        mPosMode.mode = LOC_POSITION_MODE_INVALID;
+        mFixSet = false;
+    }
     inline virtual ~UlpProxyBase() {}
-    inline virtual bool sendStartFix() { return false;}
-    inline virtual bool sendStopFix() { return false;}
-    inline virtual bool sendFixMode(LocPosMode &params) { return false;}
+    inline virtual bool sendStartFix() { mFixSet = true; return false; }
+    inline virtual bool sendStopFix() { mFixSet = false; return false; }
+    inline virtual bool sendFixMode(LocPosMode &params) {
+        mPosMode = params;
+        return false;
+    }
+
     inline virtual bool reportPosition(UlpLocation &location,
                                        GpsLocationExtended &locationExtended,
                                        void* locationExt,
@@ -54,8 +63,21 @@ public:
                                  void* svExt) {
         return false;
     }
+    inline virtual bool reportStatus(GpsStatusValue status) {
+        return false;
+    }
     inline virtual void setAdapter(LocAdapterBase* adapter) {}
     inline virtual void setCapabilities(unsigned long capabilities) {}
+    inline virtual bool reportBatchingSession(GpsExtBatchOptions &options,
+                                              bool active) {
+        return false;
+    }
+    inline virtual bool reportPositions(GpsExtLocation * locations,
+                                        int32_t number_of_locations,
+                                        enum loc_sess_status status,
+                                        LocPosTechMask techMask) {
+        return false;
+    }
 };
 
 } // namespace loc_core
diff --git a/core/gps_extended_c.h b/core/gps_extended_c.h
index e5e8546..d4a7dbe 100644
--- a/core/gps_extended_c.h
+++ b/core/gps_extended_c.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2013, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2013-2014, 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,10 +55,18 @@ extern "C" {
 /** Position source is ULP */
 #define ULP_LOCATION_IS_FROM_HYBRID   0x0001
 /** Position source is GNSS only */
-#define ULP_LOCATION_IS_FROM_GNSS   0x0002
+#define ULP_LOCATION_IS_FROM_GNSS     0x0002
+/** Position source is ZPP only */
+#define ULP_LOCATION_IS_FROM_ZPP      0x0004
+/** Position is from a Geofence Breach Event */
+#define ULP_LOCATION_IS_FROM_GEOFENCE 0X0008
+/** Positioin is from Hardware FLP */
+#define ULP_LOCATION_IS_FROM_HW_FLP   0x0010
 
 #define ULP_MIN_INTERVAL_INVALID 0xffffffff
 
+/*Emergency SUPL*/
+#define GPS_NI_TYPE_EMERGENCY_SUPL    4
 
 typedef struct {
     /** set to sizeof(UlpLocation) */
@@ -94,16 +102,6 @@ typedef int16_t AGpsBearerType;
 #define AGPS_APN_BEARER_IPV6        1
 #define AGPS_APN_BEARER_IPV4V6      2
 
-#define GPS_DELETE_ALMANAC_CORR     0x00001000
-#define GPS_DELETE_FREQ_BIAS_EST    0x00002000
-#define GPS_DELETE_EPHEMERIS_GLO    0x00004000
-#define GPS_DELETE_ALMANAC_GLO      0x00008000
-#define GPS_DELETE_SVDIR_GLO        0x00010000
-#define GPS_DELETE_SVSTEER_GLO      0x00020000
-#define GPS_DELETE_ALMANAC_CORR_GLO 0x00040000
-#define GPS_DELETE_TIME_GPS         0x00080000
-#define GPS_DELETE_TIME_GLO         0x00100000
-
 /** GPS extended callback structure. */
 typedef struct {
     /** set to sizeof(GpsCallbacks) */
@@ -115,6 +113,14 @@ typedef struct {
     gps_request_utc_time request_utc_time_cb;
 } GpsExtCallbacks;
 
+/** GPS extended batch options */
+typedef struct {
+    double max_power_allocation_mW;
+    uint32_t sources_to_use;
+    uint32_t flags;
+    int64_t period_ns;
+} GpsExtBatchOptions;
+
 /** Callback to report the xtra server url to the client.
  *  The client should use this url when downloading xtra unless overwritten
  *  in the gps.conf file
@@ -171,7 +177,8 @@ typedef enum loc_server_type {
 } LocServerType;
 
 typedef enum loc_position_mode_type {
-    LOC_POSITION_MODE_STANDALONE,
+    LOC_POSITION_MODE_INVALID = -1,
+    LOC_POSITION_MODE_STANDALONE = 0,
     LOC_POSITION_MODE_MS_BASED,
     LOC_POSITION_MODE_MS_ASSISTED,
     LOC_POSITION_MODE_RESERVED_1,
@@ -179,10 +186,27 @@ typedef enum loc_position_mode_type {
     LOC_POSITION_MODE_RESERVED_3,
     LOC_POSITION_MODE_RESERVED_4,
     LOC_POSITION_MODE_RESERVED_5
+
 } LocPositionMode;
 
 #define MIN_POSSIBLE_FIX_INTERVAL 1000 /* msec */
 
+/** GpsLocationExtended has valid latitude and longitude. */
+#define GPS_LOCATION_EXTENDED_HAS_LAT_LONG   (1U<<0)
+/** GpsLocationExtended has valid altitude. */
+#define GPS_LOCATION_EXTENDED_HAS_ALTITUDE   (1U<<1)
+/** GpsLocationExtended has valid speed. */
+#define GPS_LOCATION_EXTENDED_HAS_SPEED      (1U<<2)
+/** GpsLocationExtended has valid bearing. */
+#define GPS_LOCATION_EXTENDED_HAS_BEARING    (1U<<4)
+/** GpsLocationExtended has valid accuracy. */
+#define GPS_LOCATION_EXTENDED_HAS_ACCURACY   (1U<<8)
+
+/** GPS extended supports geofencing */
+#define GPS_EXTENDED_CAPABILITY_GEOFENCE     0x0000001
+/** GPS extended supports batching */
+#define GPS_EXTENDED_CAPABILITY_BATCHING     0x0000002
+
 /** Flags to indicate which values are valid in a GpsLocationExtended. */
 typedef uint16_t GpsLocationExtendedFlags;
 /** GpsLocationExtended has valid pdop, hdop, vdop. */
@@ -220,6 +244,19 @@ typedef struct {
     float           speed_unc;
 } GpsLocationExtended;
 
+typedef struct GpsExtLocation_s {
+    size_t          size;
+    uint16_t        flags;
+    double          latitude;
+    double          longitude;
+    double          altitude;
+    float           speed;
+    float           bearing;
+    float           accuracy;
+    int64_t         timestamp;
+    uint32_t        sources_used;
+} GpsExtLocation;
+
 enum loc_sess_status {
     LOC_SESS_SUCCESS,
     LOC_SESS_INTERMEDIATE,
@@ -275,46 +312,54 @@ enum loc_api_adapter_err {
 };
 
 enum loc_api_adapter_event_index {
-    LOC_API_ADAPTER_REPORT_POSITION = 0,       // Position report comes in loc_parsed_position_s_type
-    LOC_API_ADAPTER_REPORT_SATELLITE,          // Satellite in view report
-    LOC_API_ADAPTER_REPORT_NMEA_1HZ,           // NMEA report at 1HZ rate
-    LOC_API_ADAPTER_REPORT_NMEA_POSITION,      // NMEA report at position report rate
-    LOC_API_ADAPTER_REQUEST_NI_NOTIFY_VERIFY,  // NI notification/verification request
-    LOC_API_ADAPTER_REQUEST_ASSISTANCE_DATA,   // Assistance data, eg: time, predicted orbits request
-    LOC_API_ADAPTER_REQUEST_LOCATION_SERVER,   // Request for location server
-    LOC_API_ADAPTER_REPORT_IOCTL,              // Callback report for loc_ioctl
-    LOC_API_ADAPTER_REPORT_STATUS,             // Misc status report: eg, engine state
-    LOC_API_ADAPTER_REQUEST_WIFI,              //
-    LOC_API_ADAPTER_SENSOR_STATUS,             //
-    LOC_API_ADAPTER_REQUEST_TIME_SYNC,         //
-    LOC_API_ADAPTER_REPORT_SPI,                //
-    LOC_API_ADAPTER_REPORT_NI_GEOFENCE,        //
-    LOC_API_ADAPTER_GEOFENCE_GEN_ALERT,        //
-    LOC_API_ADAPTER_REPORT_GENFENCE_BREACH,    //
-    LOC_API_ADAPTER_PEDOMETER_CTRL,            //
-    LOC_API_ADAPTER_MOTION_CTRL,               //
+    LOC_API_ADAPTER_REPORT_POSITION = 0,               // Position report comes in loc_parsed_position_s_type
+    LOC_API_ADAPTER_REPORT_SATELLITE,                  // Satellite in view report
+    LOC_API_ADAPTER_REPORT_NMEA_1HZ,                   // NMEA report at 1HZ rate
+    LOC_API_ADAPTER_REPORT_NMEA_POSITION,              // NMEA report at position report rate
+    LOC_API_ADAPTER_REQUEST_NI_NOTIFY_VERIFY,          // NI notification/verification request
+    LOC_API_ADAPTER_REQUEST_ASSISTANCE_DATA,           // Assistance data, eg: time, predicted orbits request
+    LOC_API_ADAPTER_REQUEST_LOCATION_SERVER,           // Request for location server
+    LOC_API_ADAPTER_REPORT_IOCTL,                      // Callback report for loc_ioctl
+    LOC_API_ADAPTER_REPORT_STATUS,                     // Misc status report: eg, engine state
+    LOC_API_ADAPTER_REQUEST_WIFI,                      //
+    LOC_API_ADAPTER_SENSOR_STATUS,                     //
+    LOC_API_ADAPTER_REQUEST_TIME_SYNC,                 //
+    LOC_API_ADAPTER_REPORT_SPI,                        //
+    LOC_API_ADAPTER_REPORT_NI_GEOFENCE,                //
+    LOC_API_ADAPTER_GEOFENCE_GEN_ALERT,                //
+    LOC_API_ADAPTER_REPORT_GENFENCE_BREACH,            //
+    LOC_API_ADAPTER_PEDOMETER_CTRL,                    //
+    LOC_API_ADAPTER_MOTION_CTRL,                       //
+    LOC_API_ADAPTER_REQUEST_WIFI_AP_DATA,              // Wifi ap data
+    LOC_API_ADAPTER_BATCH_FULL,                        // Batching on full
+    LOC_API_ADAPTER_BATCHED_POSITION_REPORT,           // Batching on fix
+    LOC_API_ADAPTER_BATCHED_GENFENCE_BREACH_REPORT,    //
 
     LOC_API_ADAPTER_EVENT_MAX
 };
 
-#define LOC_API_ADAPTER_BIT_PARSED_POSITION_REPORT   (1<<LOC_API_ADAPTER_REPORT_POSITION)
-#define LOC_API_ADAPTER_BIT_SATELLITE_REPORT         (1<<LOC_API_ADAPTER_REPORT_SATELLITE)
-#define LOC_API_ADAPTER_BIT_NMEA_1HZ_REPORT          (1<<LOC_API_ADAPTER_REPORT_NMEA_1HZ)
-#define LOC_API_ADAPTER_BIT_NMEA_POSITION_REPORT     (1<<LOC_API_ADAPTER_REPORT_NMEA_POSITION)
-#define LOC_API_ADAPTER_BIT_NI_NOTIFY_VERIFY_REQUEST (1<<LOC_API_ADAPTER_REQUEST_NI_NOTIFY_VERIFY)
-#define LOC_API_ADAPTER_BIT_ASSISTANCE_DATA_REQUEST  (1<<LOC_API_ADAPTER_REQUEST_ASSISTANCE_DATA)
-#define LOC_API_ADAPTER_BIT_LOCATION_SERVER_REQUEST  (1<<LOC_API_ADAPTER_REQUEST_LOCATION_SERVER)
-#define LOC_API_ADAPTER_BIT_IOCTL_REPORT             (1<<LOC_API_ADAPTER_REPORT_IOCTL)
-#define LOC_API_ADAPTER_BIT_STATUS_REPORT            (1<<LOC_API_ADAPTER_REPORT_STATUS)
-#define LOC_API_ADAPTER_BIT_REQUEST_WIFI             (1<<LOC_API_ADAPTER_REQUEST_WIFI)
-#define LOC_API_ADAPTER_BIT_SENSOR_STATUS            (1<<LOC_API_ADAPTER_SENSOR_STATUS)
-#define LOC_API_ADAPTER_BIT_REQUEST_TIME_SYNC        (1<<LOC_API_ADAPTER_REQUEST_TIME_SYNC)
-#define LOC_API_ADAPTER_BIT_REPORT_SPI               (1<<LOC_API_ADAPTER_REPORT_SPI)
-#define LOC_API_ADAPTER_BIT_REPORT_NI_GEOFENCE       (1<<LOC_API_ADAPTER_REPORT_NI_GEOFENCE)
-#define LOC_API_ADAPTER_BIT_GEOFENCE_GEN_ALERT       (1<<LOC_API_ADAPTER_GEOFENCE_GEN_ALERT)
-#define LOC_API_ADAPTER_BIT_REPORT_GENFENCE_BREACH   (1<<LOC_API_ADAPTER_REPORT_GENFENCE_BREACH)
-#define LOC_API_ADAPTER_BIT_PEDOMETER_CTRL           (1<<LOC_API_ADAPTER_PEDOMETER_CTRL)
-#define LOC_API_ADAPTER_BIT_MOTION_CTRL              (1<<LOC_API_ADAPTER_MOTION_CTRL)
+#define LOC_API_ADAPTER_BIT_PARSED_POSITION_REPORT           (1<<LOC_API_ADAPTER_REPORT_POSITION)
+#define LOC_API_ADAPTER_BIT_SATELLITE_REPORT                 (1<<LOC_API_ADAPTER_REPORT_SATELLITE)
+#define LOC_API_ADAPTER_BIT_NMEA_1HZ_REPORT                  (1<<LOC_API_ADAPTER_REPORT_NMEA_1HZ)
+#define LOC_API_ADAPTER_BIT_NMEA_POSITION_REPORT             (1<<LOC_API_ADAPTER_REPORT_NMEA_POSITION)
+#define LOC_API_ADAPTER_BIT_NI_NOTIFY_VERIFY_REQUEST         (1<<LOC_API_ADAPTER_REQUEST_NI_NOTIFY_VERIFY)
+#define LOC_API_ADAPTER_BIT_ASSISTANCE_DATA_REQUEST          (1<<LOC_API_ADAPTER_REQUEST_ASSISTANCE_DATA)
+#define LOC_API_ADAPTER_BIT_LOCATION_SERVER_REQUEST          (1<<LOC_API_ADAPTER_REQUEST_LOCATION_SERVER)
+#define LOC_API_ADAPTER_BIT_IOCTL_REPORT                     (1<<LOC_API_ADAPTER_REPORT_IOCTL)
+#define LOC_API_ADAPTER_BIT_STATUS_REPORT                    (1<<LOC_API_ADAPTER_REPORT_STATUS)
+#define LOC_API_ADAPTER_BIT_REQUEST_WIFI                     (1<<LOC_API_ADAPTER_REQUEST_WIFI)
+#define LOC_API_ADAPTER_BIT_SENSOR_STATUS                    (1<<LOC_API_ADAPTER_SENSOR_STATUS)
+#define LOC_API_ADAPTER_BIT_REQUEST_TIME_SYNC                (1<<LOC_API_ADAPTER_REQUEST_TIME_SYNC)
+#define LOC_API_ADAPTER_BIT_REPORT_SPI                       (1<<LOC_API_ADAPTER_REPORT_SPI)
+#define LOC_API_ADAPTER_BIT_REPORT_NI_GEOFENCE               (1<<LOC_API_ADAPTER_REPORT_NI_GEOFENCE)
+#define LOC_API_ADAPTER_BIT_GEOFENCE_GEN_ALERT               (1<<LOC_API_ADAPTER_GEOFENCE_GEN_ALERT)
+#define LOC_API_ADAPTER_BIT_REPORT_GENFENCE_BREACH           (1<<LOC_API_ADAPTER_REPORT_GENFENCE_BREACH)
+#define LOC_API_ADAPTER_BIT_BATCHED_GENFENCE_BREACH_REPORT   (1<<LOC_API_ADAPTER_BATCHED_GENFENCE_BREACH_REPORT)
+#define LOC_API_ADAPTER_BIT_PEDOMETER_CTRL                   (1<<LOC_API_ADAPTER_PEDOMETER_CTRL)
+#define LOC_API_ADAPTER_BIT_MOTION_CTRL                      (1<<LOC_API_ADAPTER_MOTION_CTRL)
+#define LOC_API_ADAPTER_BIT_REQUEST_WIFI_AP_DATA             (1<<LOC_API_ADAPTER_REQUEST_WIFI_AP_DATA)
+#define LOC_API_ADAPTER_BIT_BATCH_FULL                       (1<<LOC_API_ADAPTER_BATCH_FULL)
+#define LOC_API_ADAPTER_BIT_BATCHED_POSITION_REPORT          (1<<LOC_API_ADAPTER_BATCHED_POSITION_REPORT)
 
 typedef unsigned int LOC_API_ADAPTER_EVENT_MASK_T;
 
diff --git a/core/loc_core_log.cpp b/core/loc_core_log.cpp
index f67dfe0..d2eda66 100644
--- a/core/loc_core_log.cpp
+++ b/core/loc_core_log.cpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2011-2013, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2011-2014, 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
@@ -118,13 +118,20 @@ static loc_name_val_s_type loc_eng_aiding_data_bits[] =
     NAME_VAL( GPS_DELETE_CELLDB_INFO ),
     NAME_VAL( GPS_DELETE_ALMANAC_CORR ),
     NAME_VAL( GPS_DELETE_FREQ_BIAS_EST ),
-    NAME_VAL( GPS_DELETE_EPHEMERIS_GLO ),
-    NAME_VAL( GPS_DELETE_ALMANAC_GLO ),
-    NAME_VAL( GPS_DELETE_SVDIR_GLO ),
-    NAME_VAL( GPS_DELETE_SVSTEER_GLO ),
-    NAME_VAL( GPS_DELETE_ALMANAC_CORR_GLO ),
+    NAME_VAL( GLO_DELETE_EPHEMERIS ),
+    NAME_VAL( GLO_DELETE_ALMANAC ),
+    NAME_VAL( GLO_DELETE_SVDIR ),
+    NAME_VAL( GLO_DELETE_SVSTEER ),
+    NAME_VAL( GLO_DELETE_ALMANAC_CORR ),
     NAME_VAL( GPS_DELETE_TIME_GPS ),
-    NAME_VAL( GPS_DELETE_TIME_GLO )
+    NAME_VAL( GLO_DELETE_TIME ),
+    NAME_VAL( BDS_DELETE_SVDIR ),
+    NAME_VAL( BDS_DELETE_SVSTEER ),
+    NAME_VAL( BDS_DELETE_TIME ),
+    NAME_VAL( BDS_DELETE_ALMANAC_CORR ),
+    NAME_VAL( BDS_DELETE_EPHEMERIS ),
+    NAME_VAL( BDS_DELETE_ALMANAC ),
+    NAME_VAL( GPS_DELETE_ALL)
 };
 static int loc_eng_aiding_data_bit_num = sizeof(loc_eng_aiding_data_bits) / sizeof(loc_name_val_s_type);
 
@@ -154,7 +161,8 @@ static loc_name_val_s_type loc_eng_ni_types[] =
 {
     NAME_VAL( GPS_NI_TYPE_VOICE ),
     NAME_VAL( GPS_NI_TYPE_UMTS_SUPL ),
-    NAME_VAL( GPS_NI_TYPE_UMTS_CTRL_PLANE )
+    NAME_VAL( GPS_NI_TYPE_UMTS_CTRL_PLANE ),
+    NAME_VAL( GPS_NI_TYPE_EMERGENCY_SUPL )
 };
 static int loc_eng_ni_type_num = sizeof(loc_eng_ni_types) / sizeof(loc_name_val_s_type);
 
@@ -197,7 +205,7 @@ static loc_name_val_s_type loc_eng_agps_bears[] =
 {
     NAME_VAL( AGPS_APN_BEARER_INVALID ),
     NAME_VAL( AGPS_APN_BEARER_IPV4 ),
-    NAME_VAL( AGPS_APN_BEARER_IPV4 ),
+    NAME_VAL( AGPS_APN_BEARER_IPV6 ),
     NAME_VAL( AGPS_APN_BEARER_IPV4V6 )
 };
 static int loc_eng_agps_bears_num = sizeof(loc_eng_agps_bears) / sizeof(loc_name_val_s_type);
diff --git a/etc/Android.mk b/etc/Android.mk
index 025d3f7..452dcd2 100644
--- a/etc/Android.mk
+++ b/etc/Android.mk
@@ -1,4 +1,4 @@
-
+ifeq (, $(filter aarch64 arm64, $(TARGET_ARCH)))
 LOCAL_PATH := $(call my-dir)
 include $(CLEAR_VARS)
 
@@ -9,4 +9,4 @@ LOCAL_MODULE_PATH  := $(TARGET_OUT_ETC)/
 LOCAL_SRC_FILES := gps.conf
 
 include $(BUILD_PREBUILT)
-
+endif # not aarch64
diff --git a/etc/gps.conf b/etc/gps.conf
index 60f3123..75d4113 100755
--- a/etc/gps.conf
+++ b/etc/gps.conf
@@ -1,13 +1,8 @@
-# XTRA_SERVER_QUERY (1=on, 0=off)
-# If XTRA_SERVER_QUERY is on, the XTRA_SERVERs listed
-# below will be ignored, and instead the servers will
-# be queried from the modem.
-XTRA_SERVER_QUERY=0
-# XTRA_SERVERs below are used only if XTRA_SERVER_QUERY
-# is off.
-XTRA_SERVER_1=http://xtra1.gpsonextra.net/xtra2.bin
-XTRA_SERVER_2=http://xtra2.gpsonextra.net/xtra2.bin
-XTRA_SERVER_3=http://xtra3.gpsonextra.net/xtra2.bin
+#Uncommenting these urls would only enable
+#the power up auto injection and force injection(test case).
+#XTRA_SERVER_1=http://xtra1.gpsonextra.net/xtra.bin
+#XTRA_SERVER_2=http://xtra2.gpsonextra.net/xtra.bin
+#XTRA_SERVER_3=http://xtra3.gpsonextra.net/xtra.bin
 
 # Error Estimate
 # _SET = 1
@@ -26,7 +21,7 @@ NTP_SERVER=time.gpsonextra.net
 # DEBUG LEVELS: 0 - none, 1 - Error, 2 - Warning, 3 - Info
 #               4 - Debug, 5 - Verbose
 # If DEBUG_LEVEL is commented, Android's logging levels will be used
-DEBUG_LEVEL = 2
+DEBUG_LEVEL = 3
 
 # Intermediate position report, 1=enable, 0=disable
 INTERMEDIATE_POS=0
@@ -34,6 +29,9 @@ INTERMEDIATE_POS=0
 # supl version 1.0
 SUPL_VER=0x10000
 
+# Emergency SUPL, 1=enable, 0=disable
+SUPL_ES=1
+
 # GPS Capabilities bit mask
 # SCHEDULING = 0x01
 # MSB = 0x02
@@ -75,6 +73,8 @@ LPP_PROFILE = 0
 ################################
 # NMEA provider (1=Modem Processor, 0=Application Processor)
 NMEA_PROVIDER=0
+# Mark if it is a SGLTE target (1=SGLTE, 0=nonSGLTE)
+SGLTE_TARGET=0
 
 ##################################################
 # Select Positioning Protocol on A-GLONASS system
diff --git a/loc_api/Android.mk b/loc_api/Android.mk
index 110e5ae..e58f18e 100644
--- a/loc_api/Android.mk
+++ b/loc_api/Android.mk
@@ -1,3 +1,5 @@
+ifeq (, $(filter aarch64 arm64, $(TARGET_ARCH)))
+ifneq ($(BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE),)
 
 LOCAL_PATH := $(call my-dir)
 
@@ -12,3 +14,6 @@ GPS_DIR_LIST += $(LOCAL_PATH)/libloc_api_50001/
 
 #call the subfolders
 include $(addsuffix Android.mk, $(GPS_DIR_LIST))
+
+endif#BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE
+endif # not aarch64
diff --git a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/LocApiRpc.h b/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/LocApiRpc.h
index 1b4f3f7..aafec63 100644
--- a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/LocApiRpc.h
+++ b/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/LocApiRpc.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2011,2013, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2011,2014, 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
@@ -115,11 +115,25 @@ public:
         atlCloseStatus(int handle, int is_succ);
     virtual enum loc_api_adapter_err
         setSUPLVersion(uint32_t version);
-
     virtual void setInSession(bool inSession);
+
+    /*Values for lock
+      1 = Do not lock any position sessions
+      2 = Lock MI position sessions
+      3 = Lock MT position sessions
+      4 = Lock all position sessions
+    */
+    virtual int setGpsLock(unsigned int lock);
+    /*
+     Returns
+     Current value of GPS Lock on success
+     -1 on failure
+     */
+    virtual int getGpsLock(void);
 };
 
 extern "C" LocApiBase* getLocApi(const MsgTask* msgTask,
-                                 LOC_API_ADAPTER_EVENT_MASK_T exMask);
+                                 LOC_API_ADAPTER_EVENT_MASK_T exMask,
+                                 ContextBase *context);
 
 #endif //LOC_API_RPC_H
diff --git a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/LocApiRpc.cpp b/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/LocApiRpc.cpp
index 428d5a2..e142292 100644
--- a/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/LocApiRpc.cpp
+++ b/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/LocApiRpc.cpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2011-2013, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2011-2014, 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
@@ -134,8 +134,9 @@ const rpc_loc_event_mask_type LocApiRpc::locBits[] =
 
 // constructor
 LocApiRpc::LocApiRpc(const MsgTask* msgTask,
-                     LOC_API_ADAPTER_EVENT_MASK_T exMask) :
-    LocApiBase(msgTask, exMask),
+                     LOC_API_ADAPTER_EVENT_MASK_T exMask,
+                     ContextBase* context) :
+    LocApiBase(msgTask, exMask, context),
     client_handle(RPC_LOC_CLIENT_HANDLE_INVALID),
     dataEnableLastSet(-1)
 {
@@ -1388,6 +1389,59 @@ GpsNiEncodingType LocApiRpc::convertNiEncodingType(int loc_encoding)
 }
 
 LocApiBase* getLocApi(const MsgTask* msgTask,
-                      LOC_API_ADAPTER_EVENT_MASK_T exMask) {
-    return new LocApiRpc(msgTask, exMask);
+                      LOC_API_ADAPTER_EVENT_MASK_T exMask,
+                      ContextBase *context) {
+    return new LocApiRpc(msgTask, exMask, context);
+}
+
+/*Values for lock
+  1 = Do not lock any position sessions
+  2 = Lock MI position sessions
+  3 = Lock MT position sessions
+  4 = Lock all position sessions
+*/
+int LocApiRpc::setGpsLock(unsigned int lock)
+{
+    rpc_loc_ioctl_data_u_type    ioctl_data;
+    boolean ret_val;
+    LOC_LOGD("%s:%d]: lock: %d\n", __func__, __LINE__, lock);
+    ioctl_data.rpc_loc_ioctl_data_u_type_u.engine_lock = (rpc_loc_lock_e_type)lock;
+    ioctl_data.disc = RPC_LOC_IOCTL_SET_ENGINE_LOCK;
+    ret_val = loc_eng_ioctl (loc_eng_data.client_handle,
+                            RPC_LOC_IOCTL_SET_ENGINE_LOCK,
+                            &ioctl_data,
+                            LOC_IOCTL_DEFAULT_TIMEOUT,
+                            NULL /* No output information is expected*/);
+
+    LOC_LOGD("%s:%d]: ret_val: %d\n", __func__, __LINE__, (int)ret_val);
+    return (ret_val == TRUE ? 0 : -1);
+}
+
+/*
+  Returns
+  Current value of GPS lock on success
+  -1 on failure
+*/
+int LocApiRpc :: getGpsLock()
+{
+    rpc_loc_ioctl_data_u_type    ioctl_data;
+    rpc_loc_ioctl_callback_s_type callback_payload;
+    boolean ret_val;
+    int ret=0;
+    LOC_LOGD("%s:%d]: Enter\n", __func__, __LINE__);
+    ret_val = loc_eng_ioctl (loc_eng_data.client_handle,
+                            RPC_LOC_IOCTL_GET_ENGINE_LOCK,
+                            &ioctl_data,
+                            LOC_IOCTL_DEFAULT_TIMEOUT,
+                            &callback_payload);
+    if(ret_val == TRUE) {
+        ret = (int)callback_payload.data.engine_lock;
+        LOC_LOGD("%s:%d]: Lock type: %d\n", __func__, __LINE__, ret);
+    }
+    else {
+        LOC_LOGE("%s:%d]: Ioctl failed", __func__, __LINE__);
+        ret = -1;
+    }
+    LOC_LOGD("%s:%d]: Exit\n", __func__, __LINE__);
+    return ret;
 }
diff --git a/loc_api/libloc_api/Android.mk b/loc_api/libloc_api/Android.mk
deleted file mode 100644
index 2922a4a..0000000
--- a/loc_api/libloc_api/Android.mk
+++ /dev/null
@@ -1,40 +0,0 @@
-#Compile the old library version from Google push for Passion builds with old modem image
-ifneq ($(BOARD_VENDOR_QCOM_GPS_LOC_API_AMSS_VERSION),50001)
-LOCAL_PATH := $(call my-dir)
-include $(CLEAR_VARS)
-
-LOCAL_MODULE := gps.$(BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE)
-LOCAL_MODULE_OWNER := qcom
-
-LOCAL_MODULE_TAGS := optional
-
-LOCAL_STATIC_LIBRARIES:= \
-    libloc_api-rpc 
-
-LOCAL_SHARED_LIBRARIES := \
-    librpc \
-    libutils \
-    libcutils
-
-LOCAL_SRC_FILES += \
-    loc_eng.cpp \
-    loc_eng_ioctl.cpp \
-    loc_eng_xtra.cpp \
-    loc_eng_ni.cpp \
-    gps.c
-
-LOCAL_CFLAGS += \
-    -fno-short-enums \
-    -DAMSS_VERSION=$(BOARD_VENDOR_QCOM_GPS_LOC_API_AMSS_VERSION)
-
-LOCAL_C_INCLUDES:= \
-	$(TARGET_OUT_HEADERS)/libloc_api-rpc \
-	$(TARGET_OUT_HEADERS)/libloc_api-rpc/inc \
-	$(TARGET_OUT_HEADERS)/libcommondefs-rpc/inc \
-	$(TARGET_OUT_HEADERS)/librpc
-
-
-LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/hw
-
-include $(BUILD_SHARED_LIBRARY)
-endif #BOARD_VENDOR_QCOM_GPS_LOC_API_AMSS_VERSION = 50001
diff --git a/loc_api/libloc_api/loc_eng.cpp b/loc_api/libloc_api/loc_eng.cpp
deleted file mode 100644
index 3b28630..0000000
--- a/loc_api/libloc_api/loc_eng.cpp
+++ /dev/null
@@ -1,1533 +0,0 @@
-/* Copyright (c) 2009,2011 The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above
- *       copyright notice, this list of conditions and the following
- *       disclaimer in the documentation and/or other materials provided
- *       with the distribution.
- *     * Neither the name of The Linux Foundation nor the names of its
- *       contributors may be used to endorse or promote products derived
- *       from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#define LOG_NDDEBUG 0
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <ctype.h>
-#include <math.h>
-#include <pthread.h>
-#include <arpa/inet.h>
-#include <netdb.h>
-
-#include <rpc/rpc.h>
-#include "loc_api_rpc_glue.h"
-#include "loc_apicb_appinit.h"
-
-#include <cutils/properties.h>
-#include <cutils/sched_policy.h>
-#include <utils/SystemClock.h>
-
-#include <loc_eng.h>
-#include <loc_eng_ni.h>
-
-#define LOG_TAG "lib_locapi"
-#include <utils/Log.h>
-
-// comment this out to enable logging
-// #undef LOGD
-// #define LOGD(...) {}
-
-#define DEBUG_MOCK_NI 0
-
-// Function declarations for sLocEngInterface
-static int  loc_eng_init(GpsCallbacks* callbacks);
-static int  loc_eng_start();
-static int  loc_eng_stop();
-static int  loc_eng_set_position_mode(GpsPositionMode mode, GpsPositionRecurrence recurrence,
-            uint32_t min_interval, uint32_t preferred_accuracy, uint32_t preferred_time);
-static void loc_eng_cleanup();
-static int  loc_eng_inject_time(GpsUtcTime time, int64_t timeReference, int uncertainty);
-static int  loc_eng_inject_location(double latitude, double longitude, float accuracy);
-static void loc_eng_delete_aiding_data (GpsAidingData f);
-static const void* loc_eng_get_extension(const char* name);
-
-// Function declarations for sLocEngAGpsInterface
-static void loc_eng_agps_init(AGpsCallbacks* callbacks);
-static int loc_eng_agps_data_conn_open(const char* apn);
-static int loc_eng_agps_data_conn_closed();
-static int loc_eng_agps_data_conn_failed();
-static int loc_eng_agps_set_server(AGpsType type, const char* hostname, int port);
-
-
-static int32 loc_event_cb (rpc_loc_client_handle_type client_handle,
-                           rpc_loc_event_mask_type loc_event,
-                           const rpc_loc_event_payload_u_type* loc_event_payload);
-static void loc_eng_report_position (const rpc_loc_parsed_position_s_type *location_report_ptr);
-static void loc_eng_report_sv (const rpc_loc_gnss_info_s_type *gnss_report_ptr);
-static void loc_eng_report_status (const rpc_loc_status_event_s_type *status_report_ptr);
-static void loc_eng_report_nmea (const rpc_loc_nmea_report_s_type *nmea_report_ptr);
-static void loc_eng_process_conn_request (const rpc_loc_server_request_s_type *server_request_ptr);
-
-static void loc_eng_process_deferred_action (void* arg);
-static void loc_eng_process_atl_deferred_action (int flags);
-static void loc_eng_delete_aiding_data_deferred_action (void);
-
-static int set_agps_server();
-
-// Defines the GpsInterface in gps.h
-static const GpsInterface sLocEngInterface =
-{
-    sizeof(GpsInterface),
-    loc_eng_init,
-    loc_eng_start,
-    loc_eng_stop,
-    loc_eng_cleanup,
-    loc_eng_inject_time,
-    loc_eng_inject_location,
-    loc_eng_delete_aiding_data,
-    loc_eng_set_position_mode,
-    loc_eng_get_extension,
-};
-
-static const AGpsInterface sLocEngAGpsInterface =
-{
-    sizeof(AGpsInterface),
-    loc_eng_agps_init,
-    loc_eng_agps_data_conn_open,
-    loc_eng_agps_data_conn_closed,
-    loc_eng_agps_data_conn_failed,
-    loc_eng_agps_set_server,
-};
-
-// Global data structure for location engine
-loc_eng_data_s_type loc_eng_data;
-
-/*===========================================================================
-FUNCTION    gps_get_hardware_interface
-
-DESCRIPTION
-   Returns the GPS hardware interaface based on LOC API
-   if GPS is enabled.
-
-DEPENDENCIES
-   None
-
-RETURN VALUE
-   0: success
-
-SIDE EFFECTS
-   N/A
-
-===========================================================================*/
-const GpsInterface* gps_get_hardware_interface ()
-{
-    char propBuf[PROPERTY_VALUE_MAX];
-
-    // check to see if GPS should be disabled
-    property_get("gps.disable", propBuf, "");
-    if (propBuf[0] == '1')
-    {
-        LOGD("gps_get_interface returning NULL because gps.disable=1\n");
-        return NULL;
-    }
-
-    return &sLocEngInterface;
-}
-
-/*===========================================================================
-FUNCTION    loc_eng_init
-
-DESCRIPTION
-   Initialize the location engine, this include setting up global datas
-   and registers location engien with loc api service.
-
-DEPENDENCIES
-   None
-
-RETURN VALUE
-   0: success
-
-SIDE EFFECTS
-   N/A
-
-===========================================================================*/
-
-// fully shutting down the GPS is temporarily disabled to avoid intermittent BP crash
-#define DISABLE_CLEANUP 1
-
-static int loc_eng_init(GpsCallbacks* callbacks)
-{
-#if DISABLE_CLEANUP
-    if (loc_eng_data.deferred_action_thread) {
-        // already initialized
-        return 0;
-    }
-#endif
-    // Start the LOC api RPC service
-    loc_api_glue_init ();
-
-    callbacks->set_capabilities_cb(GPS_CAPABILITY_SCHEDULING | GPS_CAPABILITY_MSA | GPS_CAPABILITY_MSB);
-
-    memset (&loc_eng_data, 0, sizeof (loc_eng_data_s_type));
-
-    // LOC ENG module data initialization
-    loc_eng_data.location_cb    = callbacks->location_cb;
-    loc_eng_data.sv_status_cb   = callbacks->sv_status_cb;
-    loc_eng_data.status_cb      = callbacks->status_cb;
-    loc_eng_data.nmea_cb        = callbacks->nmea_cb;
-    loc_eng_data.acquire_wakelock_cb = callbacks->acquire_wakelock_cb;
-    loc_eng_data.release_wakelock_cb = callbacks->release_wakelock_cb;
-
-    rpc_loc_event_mask_type event = RPC_LOC_EVENT_PARSED_POSITION_REPORT |
-                                    RPC_LOC_EVENT_SATELLITE_REPORT |
-                                    RPC_LOC_EVENT_LOCATION_SERVER_REQUEST |
-                                    RPC_LOC_EVENT_ASSISTANCE_DATA_REQUEST |
-                                    RPC_LOC_EVENT_IOCTL_REPORT |
-                                    RPC_LOC_EVENT_STATUS_REPORT |
-                                    RPC_LOC_EVENT_NMEA_POSITION_REPORT |
-                                    RPC_LOC_EVENT_NI_NOTIFY_VERIFY_REQUEST;
-
-    loc_eng_data.client_handle = loc_open (event, loc_event_cb);
-
-    pthread_mutex_init (&(loc_eng_data.deferred_action_mutex), NULL);
-    pthread_cond_init  (&(loc_eng_data.deferred_action_cond) , NULL);
-     pthread_mutex_init (&(loc_eng_data.deferred_stop_mutex), NULL);
-
-    loc_eng_data.loc_event = 0;
-    loc_eng_data.deferred_action_flags = 0;
-    memset (loc_eng_data.apn_name, 0, sizeof (loc_eng_data.apn_name));
-
-    loc_eng_data.aiding_data_for_deletion = 0;
-    loc_eng_data.engine_status = GPS_STATUS_NONE;
-
-    // XTRA module data initialization
-    loc_eng_data.xtra_module_data.download_request_cb = NULL;
-
-    // IOCTL module data initialization
-    loc_eng_data.ioctl_data.cb_is_selected  = FALSE;
-    loc_eng_data.ioctl_data.cb_is_waiting   = FALSE;
-    loc_eng_data.ioctl_data.client_handle   = RPC_LOC_CLIENT_HANDLE_INVALID;
-    memset (&(loc_eng_data.ioctl_data.cb_payload),
-            0,
-            sizeof (rpc_loc_ioctl_callback_s_type));
-
-    pthread_mutex_init (&(loc_eng_data.ioctl_data.cb_data_mutex), NULL);
-    pthread_cond_init(&loc_eng_data.ioctl_data.cb_arrived_cond, NULL);
-
-    loc_eng_data.deferred_action_thread = callbacks->create_thread_cb("loc_api",
-                                            loc_eng_process_deferred_action, NULL);
-
-    LOGD ("loc_eng_init called, client id = %d\n", (int32) loc_eng_data.client_handle);
-    return 0;
-}
-
-/*===========================================================================
-FUNCTION    loc_eng_cleanup
-
-DESCRIPTION
-   Cleans location engine. The location client handle will be released.
-
-DEPENDENCIES
-   None
-
-RETURN VALUE
-   None
-
-SIDE EFFECTS
-   N/A
-
-===========================================================================*/
-static void loc_eng_cleanup()
-{
-#if DISABLE_CLEANUP
-    return;
-#else
-    if (loc_eng_data.deferred_action_thread)
-    {
-        /* Terminate deferred action working thread */
-        pthread_mutex_lock(&loc_eng_data.deferred_action_mutex);
-        /* hold a wake lock while events are pending for deferred_action_thread */
-        loc_eng_data.acquire_wakelock_cb();
-        loc_eng_data.deferred_action_flags |= DEFERRED_ACTION_QUIT;
-        pthread_cond_signal(&loc_eng_data.deferred_action_cond);
-        pthread_mutex_unlock(&loc_eng_data.deferred_action_mutex);
-
-        void* ignoredValue;
-        pthread_join(loc_eng_data.deferred_action_thread, &ignoredValue);
-        loc_eng_data.deferred_action_thread = NULL;
-    }
-
-    // clean up
-    (void) loc_close (loc_eng_data.client_handle);
-
-    pthread_mutex_destroy (&loc_eng_data.deferred_action_mutex);
-    pthread_cond_destroy  (&loc_eng_data.deferred_action_cond);
-
-    pthread_mutex_destroy (&loc_eng_data.ioctl_data.cb_data_mutex);
-    pthread_cond_destroy  (&loc_eng_data.ioctl_data.cb_arrived_cond);
-
-// Do not call this as it can result in the ARM9 crashing if it sends events while we are disabled
-//    loc_apicb_app_deinit();
-#endif
-}
-
-
-/*===========================================================================
-FUNCTION    loc_eng_start
-
-DESCRIPTION
-   Starts the tracking session
-
-DEPENDENCIES
-   None
-
-RETURN VALUE
-   0: success
-
-SIDE EFFECTS
-   N/A
-
-===========================================================================*/
-static int loc_eng_start()
-{
-    int ret_val;
-    LOGD ("loc_eng_start\n");
-
-    if (loc_eng_data.position_mode != GPS_POSITION_MODE_STANDALONE &&
-            loc_eng_data.agps_server_host[0] != 0 &&
-            loc_eng_data.agps_server_port != 0) {
-        int result = set_agps_server();
-        LOGD ("set_agps_server returned = %d\n", result);
-    }
-
-    ret_val = loc_start_fix (loc_eng_data.client_handle);
-
-    if (ret_val != RPC_LOC_API_SUCCESS)
-    {
-        LOGD ("loc_eng_start returned error = %d\n", ret_val);
-    }
-
-    return 0;
-}
-
-
-/*===========================================================================
-FUNCTION    loc_eng_stop
-
-DESCRIPTION
-   Stops the tracking session
-
-DEPENDENCIES
-   None
-
-RETURN VALUE
-   0: success
-
-SIDE EFFECTS
-   N/A
-
-===========================================================================*/
-static int loc_eng_stop()
-{
-    int ret_val;
-
-    LOGD ("loc_eng_stop\n");
-
-    pthread_mutex_lock(&(loc_eng_data.deferred_stop_mutex));
-    // work around problem with loc_eng_stop when AGPS requests are pending
-    // we defer stopping the engine until the AGPS request is done
-    if (loc_eng_data.agps_request_pending)
-    {
-        loc_eng_data.stop_request_pending = true;
-        LOGD ("deferring stop until AGPS data call is finished\n");
-        pthread_mutex_unlock(&(loc_eng_data.deferred_stop_mutex));
-        return 0;
-    }
-    pthread_mutex_unlock(&(loc_eng_data.deferred_stop_mutex));
-
-    ret_val = loc_stop_fix (loc_eng_data.client_handle);
-    if (ret_val != RPC_LOC_API_SUCCESS)
-    {
-        LOGD ("loc_eng_stop returned error = %d\n", ret_val);
-    }
-
-    return 0;
-}
-
-static int loc_eng_set_gps_lock(rpc_loc_lock_e_type lock_type)
-{
-    rpc_loc_ioctl_data_u_type    ioctl_data;
-    boolean                      ret_val;
-
-    LOGD ("loc_eng_set_gps_lock mode, client = %d, lock_type = %d\n",
-            (int32) loc_eng_data.client_handle, lock_type);
-
-    ioctl_data.rpc_loc_ioctl_data_u_type_u.engine_lock = lock_type;
-    ioctl_data.disc = RPC_LOC_IOCTL_SET_ENGINE_LOCK;
-
-    ret_val = loc_eng_ioctl (loc_eng_data.client_handle,
-                            RPC_LOC_IOCTL_SET_ENGINE_LOCK,
-                            &ioctl_data,
-                            LOC_IOCTL_DEFAULT_TIMEOUT,
-                            NULL /* No output information is expected*/);
-
-    if (ret_val != TRUE)
-    {
-        LOGD ("loc_eng_set_gps_lock mode failed\n");
-    }
-
-    return 0;
-}
-
-/*===========================================================================
-FUNCTION    loc_eng_set_position_mode
-
-DESCRIPTION
-   Sets the mode and fix frequency for the tracking session.
-
-DEPENDENCIES
-   None
-
-RETURN VALUE
-   0: success
-
-SIDE EFFECTS
-   N/A
-
-===========================================================================*/
-static int loc_eng_set_position_mode(GpsPositionMode mode, GpsPositionRecurrence recurrence,
-            uint32_t min_interval, uint32_t preferred_accuracy, uint32_t preferred_time)
-{
-    rpc_loc_ioctl_data_u_type    ioctl_data;
-    rpc_loc_fix_criteria_s_type *fix_criteria_ptr;
-    boolean                      ret_val;
-
-    LOGD ("loc_eng_set_position mode, client = %d, interval = %d, mode = %d\n",
-            (int32) loc_eng_data.client_handle, min_interval, mode);
-
-    loc_eng_data.position_mode = mode;
-    ioctl_data.disc = RPC_LOC_IOCTL_SET_FIX_CRITERIA;
-
-    fix_criteria_ptr = &(ioctl_data.rpc_loc_ioctl_data_u_type_u.fix_criteria);
-    fix_criteria_ptr->valid_mask = RPC_LOC_FIX_CRIT_VALID_PREFERRED_OPERATION_MODE |
-                                   RPC_LOC_FIX_CRIT_VALID_RECURRENCE_TYPE;
-
-    switch (mode) {
-        case GPS_POSITION_MODE_MS_BASED:
-            fix_criteria_ptr->preferred_operation_mode = RPC_LOC_OPER_MODE_MSB;
-            break;
-        case GPS_POSITION_MODE_MS_ASSISTED:
-            fix_criteria_ptr->preferred_operation_mode = RPC_LOC_OPER_MODE_MSA;
-            break;
-        case GPS_POSITION_MODE_STANDALONE:
-        default:
-            fix_criteria_ptr->preferred_operation_mode = RPC_LOC_OPER_MODE_STANDALONE;
-            break;
-    }
-    if (min_interval > 0) {
-        fix_criteria_ptr->min_interval = min_interval;
-        fix_criteria_ptr->valid_mask |= RPC_LOC_FIX_CRIT_VALID_MIN_INTERVAL;
-    }
-    if (preferred_accuracy > 0) {
-        fix_criteria_ptr->preferred_accuracy = preferred_accuracy;
-        fix_criteria_ptr->valid_mask |= RPC_LOC_FIX_CRIT_VALID_PREFERRED_ACCURACY;
-    }
-    if (preferred_time > 0) {
-        fix_criteria_ptr->preferred_response_time = preferred_time;
-        fix_criteria_ptr->valid_mask |= RPC_LOC_FIX_CRIT_VALID_PREFERRED_RESPONSE_TIME;
-    }
-
-    switch (recurrence) {
-        case GPS_POSITION_RECURRENCE_SINGLE:
-            fix_criteria_ptr->recurrence_type = RPC_LOC_SINGLE_FIX;
-            break;
-        case GPS_POSITION_RECURRENCE_PERIODIC:
-        default:
-            fix_criteria_ptr->recurrence_type = RPC_LOC_PERIODIC_FIX;
-            break;
-    }
-
-    ret_val = loc_eng_ioctl(loc_eng_data.client_handle,
-                            RPC_LOC_IOCTL_SET_FIX_CRITERIA,
-                            &ioctl_data,
-                            LOC_IOCTL_DEFAULT_TIMEOUT,
-                            NULL /* No output information is expected*/);
-
-    if (ret_val != TRUE)
-    {
-        LOGD ("loc_eng_set_position mode failed\n");
-    }
-
-    return 0;
-}
-
-/*===========================================================================
-FUNCTION    loc_eng_inject_time
-
-DESCRIPTION
-   This is used by Java native function to do time injection.
-
-DEPENDENCIES
-   None
-
-RETURN VALUE
-   RPC_LOC_API_SUCCESS
-
-SIDE EFFECTS
-   N/A
-
-===========================================================================*/
-static int loc_eng_inject_time (GpsUtcTime time, int64_t timeReference, int uncertainty)
-{
-    rpc_loc_ioctl_data_u_type       ioctl_data;
-    rpc_loc_assist_data_time_s_type *time_info_ptr;
-    boolean                          ret_val;
-
-    LOGD ("loc_eng_inject_time, uncertainty = %d\n", uncertainty);
-
-    ioctl_data.disc = RPC_LOC_IOCTL_INJECT_UTC_TIME;
-
-    time_info_ptr = &(ioctl_data.rpc_loc_ioctl_data_u_type_u.assistance_data_time);
-    time_info_ptr->time_utc = time;
-    time_info_ptr->time_utc += (int64_t)(android::elapsedRealtime() - timeReference);
-    time_info_ptr->uncertainty = uncertainty; // Uncertainty in ms
-
-    ret_val = loc_eng_ioctl (loc_eng_data.client_handle,
-                             RPC_LOC_IOCTL_INJECT_UTC_TIME,
-                             &ioctl_data,
-                             LOC_IOCTL_DEFAULT_TIMEOUT,
-                             NULL /* No output information is expected*/);
-
-    if (ret_val != TRUE)
-    {
-        LOGD ("loc_eng_inject_time failed\n");
-    }
-
-    return 0;
-}
-
-static int loc_eng_inject_location (double latitude, double longitude, float accuracy)
-{
-    /* not yet implemented */
-    return 0;
-}
-
-/*===========================================================================
-FUNCTION    loc_eng_delete_aiding_data
-
-DESCRIPTION
-   This is used by Java native function to delete the aiding data. The function
-   updates the global variable for the aiding data to be deleted. If the GPS
-   engine is off, the aiding data will be deleted. Otherwise, the actual action
-   will happen when gps engine is turned off.
-
-DEPENDENCIES
-   Assumes the aiding data type specified in GpsAidingData matches with
-   LOC API specification.
-
-RETURN VALUE
-   RPC_LOC_API_SUCCESS
-
-SIDE EFFECTS
-   N/A
-
-===========================================================================*/
-static void loc_eng_delete_aiding_data (GpsAidingData f)
-{
-    pthread_mutex_lock(&(loc_eng_data.deferred_action_mutex));
-
-    // Currently, LOC API only support deletion of all aiding data,
-    if (f)
-        loc_eng_data.aiding_data_for_deletion = GPS_DELETE_ALL;
-
-    if ((loc_eng_data.engine_status != GPS_STATUS_SESSION_BEGIN) &&
-        (loc_eng_data.aiding_data_for_deletion != 0))
-    {
-        /* hold a wake lock while events are pending for deferred_action_thread */
-        loc_eng_data.acquire_wakelock_cb();
-        loc_eng_data.deferred_action_flags |= DEFERRED_ACTION_DELETE_AIDING;
-        pthread_cond_signal(&(loc_eng_data.deferred_action_cond));
-
-        // In case gps engine is ON, the assistance data will be deleted when the engine is OFF
-    }
-
-    pthread_mutex_unlock(&(loc_eng_data.deferred_action_mutex));
-}
-
-/*===========================================================================
-FUNCTION    loc_eng_get_extension
-
-DESCRIPTION
-   Get the gps extension to support XTRA.
-
-DEPENDENCIES
-   N/A
-
-RETURN VALUE
-   The GPS extension interface.
-
-SIDE EFFECTS
-   N/A
-
-===========================================================================*/
-static const void* loc_eng_get_extension(const char* name)
-{
-    if (strcmp(name, GPS_XTRA_INTERFACE) == 0)
-    {
-        return &sLocEngXTRAInterface;
-    }
-    else if (strcmp(name, AGPS_INTERFACE) == 0)
-    {
-        return &sLocEngAGpsInterface;
-    }
-    else if (strcmp(name, GPS_NI_INTERFACE) == 0)
-    {
-        return &sLocEngNiInterface;
-    }
-
-    return NULL;
-}
-
-#if DEBUG_MOCK_NI == 1
-/*===========================================================================
-FUNCTION    mock_ni
-
-DESCRIPTION
-   DEBUG tool: simulate an NI request
-
-DEPENDENCIES
-   N/A
-
-RETURN VALUE
-   None
-
-SIDE EFFECTS
-   N/A
-
-===========================================================================*/
-static void* mock_ni(void* arg)
-{
-    static int busy = 0;
-
-    if (busy) return NULL;
-
-    busy = 1;
-
-    sleep(5);
-
-    rpc_loc_client_handle_type           client_handle;
-    rpc_loc_event_mask_type              loc_event;
-    rpc_loc_event_payload_u_type         payload;
-    rpc_loc_ni_event_s_type             *ni_req;
-    rpc_loc_ni_supl_notify_verify_req_s_type *supl_req;
-
-    client_handle = (rpc_loc_client_handle_type) arg;
-
-    loc_event = RPC_LOC_EVENT_NI_NOTIFY_VERIFY_REQUEST;
-    payload.disc = loc_event;
-
-    ni_req = &payload.rpc_loc_event_payload_u_type_u.ni_request;
-    ni_req->event = RPC_LOC_NI_EVENT_SUPL_NOTIFY_VERIFY_REQ;
-    supl_req = &ni_req->payload.rpc_loc_ni_event_payload_u_type_u.supl_req;
-
-    // Encodings for Spirent Communications
-    char client_name[80]  = {0x53,0x78,0x5A,0x5E,0x76,0xD3,0x41,0xC3,0x77,
-            0xBB,0x5D,0x77,0xA7,0xC7,0x61,0x7A,0xFA,0xED,0x9E,0x03};
-    char requestor_id[80] = {0x53,0x78,0x5A,0x5E,0x76,0xD3,0x41,0xC3,0x77,
-            0xBB,0x5D,0x77,0xA7,0xC7,0x61,0x7A,0xFA,0xED,0x9E,0x03};
-
-    supl_req->flags = RPC_LOC_NI_CLIENT_NAME_PRESENT |
-                      RPC_LOC_NI_REQUESTOR_ID_PRESENT |
-                      RPC_LOC_NI_ENCODING_TYPE_PRESENT;
-
-    supl_req->datacoding_scheme = RPC_LOC_NI_SUPL_GSM_DEFAULT;
-
-    supl_req->client_name.data_coding_scheme = RPC_LOC_NI_SUPL_GSM_DEFAULT; // no coding
-    supl_req->client_name.client_name_string.client_name_string_len = strlen(client_name);
-    supl_req->client_name.client_name_string.client_name_string_val = client_name;
-    supl_req->client_name.string_len = strlen(client_name);
-
-    supl_req->requestor_id.data_coding_scheme = RPC_LOC_NI_SUPL_GSM_DEFAULT;
-    supl_req->requestor_id.requestor_id_string.requestor_id_string_len = strlen(requestor_id);
-    supl_req->requestor_id.requestor_id_string.requestor_id_string_val = requestor_id;
-    supl_req->requestor_id.string_len = strlen(requestor_id);
-
-    supl_req->notification_priv_type = RPC_LOC_NI_USER_NOTIFY_VERIFY_ALLOW_NO_RESP;
-    supl_req->user_response_timer = 10;
-
-    loc_event_cb(client_handle, loc_event, &payload);
-
-    busy = 0;
-
-    return NULL;
-}
-#endif // DEBUG_MOCK_NI
-
-/*===========================================================================
-FUNCTION    loc_event_cb
-
-DESCRIPTION
-   This is the callback function registered by loc_open.
-
-DEPENDENCIES
-   N/A
-
-RETURN VALUE
-   RPC_LOC_API_SUCCESS
-
-SIDE EFFECTS
-   N/A
-
-===========================================================================*/
-static int32 loc_event_cb(
-    rpc_loc_client_handle_type           client_handle,
-    rpc_loc_event_mask_type              loc_event,
-    const rpc_loc_event_payload_u_type*  loc_event_payload
-    )
-{
-    LOGV ("loc_event_cb, client = %d, loc_event = 0x%x", (int32) client_handle, (uint32) loc_event);
-    if (client_handle == loc_eng_data.client_handle)
-    {
-        pthread_mutex_lock(&loc_eng_data.deferred_action_mutex);
-        loc_eng_data.loc_event = loc_event;
-        memcpy(&loc_eng_data.loc_event_payload, loc_event_payload, sizeof(*loc_event_payload));
-
-        /* hold a wake lock while events are pending for deferred_action_thread */
-        loc_eng_data.acquire_wakelock_cb();
-        loc_eng_data.deferred_action_flags |= DEFERRED_ACTION_EVENT;
-        pthread_cond_signal(&loc_eng_data.deferred_action_cond);
-        pthread_mutex_unlock(&loc_eng_data.deferred_action_mutex);
-    }
-    else
-    {
-        LOGD ("loc client mismatch: received = %d, expected = %d \n", (int32) client_handle, (int32) loc_eng_data.client_handle);
-    }
-
-    return RPC_LOC_API_SUCCESS;
-}
-
-/*===========================================================================
-FUNCTION    loc_eng_report_position
-
-DESCRIPTION
-   Reports position information to the Java layer.
-
-DEPENDENCIES
-   N/A
-
-RETURN VALUE
-   N/A
-
-SIDE EFFECTS
-   N/A
-
-===========================================================================*/
-static void loc_eng_report_position (const rpc_loc_parsed_position_s_type *location_report_ptr)
-{
-    UlpLocation location;
-
-    LOGV ("loc_eng_report_position: location report, valid mask = 0x%x, sess status = %d\n",
-         (uint32) location_report_ptr->valid_mask, location_report_ptr->session_status);
-
-    memset (&location, 0, sizeof(location));
-    location.size = sizeof(location);
-    if (location_report_ptr->valid_mask & RPC_LOC_POS_VALID_SESSION_STATUS)
-    {
-        // Not a position report, return
-        if (location_report_ptr->session_status == RPC_LOC_SESS_STATUS_SUCCESS)
-        {
-            if (location_report_ptr->valid_mask & RPC_LOC_POS_VALID_TIMESTAMP_UTC)
-            {
-                location.timestamp = location_report_ptr->timestamp_utc;
-            }
-
-            if ((location_report_ptr->valid_mask & RPC_LOC_POS_VALID_LATITUDE) &&
-                (location_report_ptr->valid_mask & RPC_LOC_POS_VALID_LONGITUDE))
-            {
-                location.flags    |= GPS_LOCATION_HAS_LAT_LONG;
-                location.latitude  = location_report_ptr->latitude;
-                location.longitude = location_report_ptr->longitude;
-            }
-
-            if (location_report_ptr->valid_mask &  RPC_LOC_POS_VALID_ALTITUDE_WRT_ELLIPSOID )
-            {
-                location.flags    |= GPS_LOCATION_HAS_ALTITUDE;
-                location.altitude = location_report_ptr->altitude_wrt_ellipsoid;
-            }
-
-            if ((location_report_ptr->valid_mask & RPC_LOC_POS_VALID_SPEED_HORIZONTAL) &&
-                (location_report_ptr->valid_mask & RPC_LOC_POS_VALID_SPEED_VERTICAL))
-            {
-                location.flags    |= GPS_LOCATION_HAS_SPEED;
-                location.speed = sqrt(location_report_ptr->speed_horizontal * location_report_ptr->speed_horizontal +
-                                     location_report_ptr->speed_vertical * location_report_ptr->speed_vertical);
-            }
-
-            if (location_report_ptr->valid_mask &  RPC_LOC_POS_VALID_HEADING)
-            {
-                location.flags    |= GPS_LOCATION_HAS_BEARING;
-                location.bearing = location_report_ptr->heading;
-            }
-
-            if (location_report_ptr->valid_mask & RPC_LOC_POS_VALID_HOR_UNC_CIRCULAR)
-            {
-                location.flags    |= GPS_LOCATION_HAS_ACCURACY;
-                location.accuracy = location_report_ptr->hor_unc_circular;
-            }
-
-            if (loc_eng_data.location_cb != NULL)
-            {
-                LOGV ("loc_eng_report_position: fire callback\n");
-                loc_eng_data.location_cb (&location);
-            }
-        }
-        else
-        {
-            LOGV ("loc_eng_report_position: ignore position report when session status = %d\n", location_report_ptr->session_status);
-        }
-    }
-    else
-    {
-        LOGV ("loc_eng_report_position: ignore position report when session status is not set\n");
-    }
-}
-
-/*===========================================================================
-FUNCTION    loc_eng_report_sv
-
-DESCRIPTION
-   Reports GPS satellite information to the Java layer.
-
-DEPENDENCIES
-   N/A
-
-RETURN VALUE
-   N/A
-
-SIDE EFFECTS
-   N/A
-
-===========================================================================*/
-static void loc_eng_report_sv (const rpc_loc_gnss_info_s_type *gnss_report_ptr)
-{
-    GpsSvStatus     SvStatus;
-    int             num_svs_max, i;
-    const rpc_loc_sv_info_s_type *sv_info_ptr;
-
-    LOGV ("loc_eng_report_sv: valid_mask = 0x%x, num of sv = %d\n",
-            (uint32) gnss_report_ptr->valid_mask,
-            gnss_report_ptr->sv_count);
-
-    num_svs_max = 0;
-    memset (&SvStatus, 0, sizeof (GpsSvStatus));
-    if (gnss_report_ptr->valid_mask & RPC_LOC_GNSS_INFO_VALID_SV_COUNT)
-    {
-        num_svs_max = gnss_report_ptr->sv_count;
-        if (num_svs_max > GPS_MAX_SVS)
-        {
-            num_svs_max = GPS_MAX_SVS;
-        }
-    }
-
-    if (gnss_report_ptr->valid_mask & RPC_LOC_GNSS_INFO_VALID_SV_LIST)
-    {
-        SvStatus.num_svs = 0;
-
-        for (i = 0; i < num_svs_max; i++)
-        {
-            sv_info_ptr = &(gnss_report_ptr->sv_list.sv_list_val[i]);
-            if (sv_info_ptr->valid_mask & RPC_LOC_SV_INFO_VALID_SYSTEM)
-            {
-                if (sv_info_ptr->system == RPC_LOC_SV_SYSTEM_GPS)
-                {
-                    SvStatus.sv_list[SvStatus.num_svs].size = sizeof(GpsSvStatus);
-                    SvStatus.sv_list[SvStatus.num_svs].prn = sv_info_ptr->prn;
-
-                    // We only have the data field to report gps eph and alm mask
-                    if ((sv_info_ptr->valid_mask & RPC_LOC_SV_INFO_VALID_HAS_EPH) &&
-                        (sv_info_ptr->has_eph == 1))
-                    {
-                        SvStatus.ephemeris_mask |= (1 << (sv_info_ptr->prn-1));
-                    }
-
-                    if ((sv_info_ptr->valid_mask & RPC_LOC_SV_INFO_VALID_HAS_ALM) &&
-                        (sv_info_ptr->has_alm == 1))
-                    {
-                        SvStatus.almanac_mask |= (1 << (sv_info_ptr->prn-1));
-                    }
-
-                    if ((sv_info_ptr->valid_mask & RPC_LOC_SV_INFO_VALID_PROCESS_STATUS) &&
-                        (sv_info_ptr->process_status == RPC_LOC_SV_STATUS_TRACK))
-                    {
-                        SvStatus.used_in_fix_mask |= (1 << (sv_info_ptr->prn-1));
-                    }
-                }
-                // SBAS: GPS RPN: 120-151,
-                // In exteneded measurement report, we follow nmea standard, which is from 33-64.
-                else if (sv_info_ptr->system == RPC_LOC_SV_SYSTEM_SBAS)
-                {
-                    SvStatus.sv_list[SvStatus.num_svs].prn = sv_info_ptr->prn + 33 - 120;
-                }
-                // Gloness: Slot id: 1-32
-                // In extended measurement report, we follow nmea standard, which is 65-96
-                else if (sv_info_ptr->system == RPC_LOC_SV_SYSTEM_GLONASS)
-                {
-                    SvStatus.sv_list[SvStatus.num_svs].prn = sv_info_ptr->prn + (65-1);
-                }
-                // Unsupported SV system
-                else
-                {
-                    continue;
-                }
-            }
-
-            if (sv_info_ptr->valid_mask & RPC_LOC_SV_INFO_VALID_SNR)
-            {
-                SvStatus.sv_list[SvStatus.num_svs].snr = sv_info_ptr->snr;
-            }
-
-            if (sv_info_ptr->valid_mask & RPC_LOC_SV_INFO_VALID_ELEVATION)
-            {
-                SvStatus.sv_list[SvStatus.num_svs].elevation = sv_info_ptr->elevation;
-            }
-
-            if (sv_info_ptr->valid_mask & RPC_LOC_SV_INFO_VALID_AZIMUTH)
-            {
-                SvStatus.sv_list[SvStatus.num_svs].azimuth = sv_info_ptr->azimuth;
-            }
-
-            SvStatus.num_svs++;
-        }
-    }
-
-    LOGV ("num_svs = %d, eph mask = %d, alm mask = %d\n", SvStatus.num_svs, SvStatus.ephemeris_mask, SvStatus.almanac_mask );
-    if ((SvStatus.num_svs != 0) && (loc_eng_data.sv_status_cb != NULL))
-    {
-        loc_eng_data.sv_status_cb(&SvStatus);
-    }
-}
-
-/*===========================================================================
-FUNCTION    loc_eng_report_status
-
-DESCRIPTION
-   Reports GPS engine state to Java layer.
-
-DEPENDENCIES
-   N/A
-
-RETURN VALUE
-   N/A
-
-SIDE EFFECTS
-   N/A
-
-===========================================================================*/
-static void loc_eng_report_status (const rpc_loc_status_event_s_type *status_report_ptr)
-{
-    GpsStatus status;
-
-    LOGV ("loc_eng_report_status: event = %d\n", status_report_ptr->event);
-
-    memset (&status, 0, sizeof(status));
-    status.size = sizeof(status);
-    status.status = GPS_STATUS_NONE;
-    if (status_report_ptr->event == RPC_LOC_STATUS_EVENT_ENGINE_STATE)
-    {
-        if (status_report_ptr->payload.rpc_loc_status_event_payload_u_type_u.engine_state == RPC_LOC_ENGINE_STATE_ON)
-        {
-            // GPS_STATUS_SESSION_BEGIN implies GPS_STATUS_ENGINE_ON
-            status.status = GPS_STATUS_SESSION_BEGIN;
-            loc_eng_data.status_cb(&status);
-        }
-        else if (status_report_ptr->payload.rpc_loc_status_event_payload_u_type_u.engine_state == RPC_LOC_ENGINE_STATE_OFF)
-        {
-            // GPS_STATUS_SESSION_END implies GPS_STATUS_ENGINE_OFF
-            status.status = GPS_STATUS_ENGINE_OFF;
-            loc_eng_data.status_cb(&status);
-        }
-    }
-
-    pthread_mutex_lock(&loc_eng_data.deferred_action_mutex);
-    loc_eng_data.engine_status = status.status;
-
-    // Wake up the thread for aiding data deletion.
-    if ((loc_eng_data.engine_status != GPS_STATUS_SESSION_BEGIN) &&
-        (loc_eng_data.aiding_data_for_deletion != 0))
-    {
-        /* hold a wake lock while events are pending for deferred_action_thread */
-        loc_eng_data.acquire_wakelock_cb();
-        loc_eng_data.deferred_action_flags |= DEFERRED_ACTION_DELETE_AIDING;
-        pthread_cond_signal(&(loc_eng_data.deferred_action_cond));
-        // In case gps engine is ON, the assistance data will be deleted when the engine is OFF
-    }
-
-    pthread_mutex_unlock(&loc_eng_data.deferred_action_mutex);
-}
-
-static void loc_eng_report_nmea (const rpc_loc_nmea_report_s_type *nmea_report_ptr)
-{
-    if (loc_eng_data.nmea_cb != NULL)
-    {
-        struct timeval tv;
-
-        gettimeofday(&tv, (struct timezone *) NULL);
-        long long now = tv.tv_sec * 1000LL + tv.tv_usec / 1000;
-
-#if (AMSS_VERSION==3200)
-        loc_eng_data.nmea_cb(now, nmea_report_ptr->nmea_sentences.nmea_sentences_val,
-                nmea_report_ptr->nmea_sentences.nmea_sentences_len);
-#else
-        loc_eng_data.nmea_cb(now, nmea_report_ptr->nmea_sentences, nmea_report_ptr->length);
-#endif
-    }
-}
-
-/*===========================================================================
-FUNCTION    loc_eng_process_conn_request
-
-DESCRIPTION
-   Requests data connection to be brought up/tore down with the location server.
-
-DEPENDENCIES
-   N/A
-
-RETURN VALUE
-   N/A
-
-SIDE EFFECTS
-   N/A
-
-===========================================================================*/
-static void loc_eng_process_conn_request (const rpc_loc_server_request_s_type *server_request_ptr)
-{
-    LOGD ("loc_event_cb: get loc event location server request, event = %d\n", server_request_ptr->event);
-
-    // Signal DeferredActionThread to send the APN name
-    pthread_mutex_lock(&loc_eng_data.deferred_action_mutex);
-
-    // This implemenation is based on the fact that modem now at any time has only one data connection for AGPS at any given time
-    if (server_request_ptr->event == RPC_LOC_SERVER_REQUEST_OPEN)
-    {
-        loc_eng_data.conn_handle = server_request_ptr->payload.rpc_loc_server_request_u_type_u.open_req.conn_handle;
-        loc_eng_data.agps_status = GPS_REQUEST_AGPS_DATA_CONN;
-        loc_eng_data.agps_request_pending = true;
-    }
-    else
-    {
-        loc_eng_data.conn_handle = server_request_ptr->payload.rpc_loc_server_request_u_type_u.close_req.conn_handle;
-        loc_eng_data.agps_status = GPS_RELEASE_AGPS_DATA_CONN;
-        loc_eng_data.agps_request_pending = false;
-    }
-
-    /* hold a wake lock while events are pending for deferred_action_thread */
-    loc_eng_data.acquire_wakelock_cb();
-    loc_eng_data.deferred_action_flags |= DEFERRED_ACTION_AGPS_STATUS;
-    pthread_cond_signal(&loc_eng_data.deferred_action_cond);
-    pthread_mutex_unlock(&loc_eng_data.deferred_action_mutex);
-}
-
-/*===========================================================================
-FUNCTION    loc_eng_agps_init
-
-DESCRIPTION
-
-
-DEPENDENCIES
-   NONE
-
-RETURN VALUE
-   0
-
-SIDE EFFECTS
-   N/A
-
-===========================================================================*/
-static void loc_eng_agps_init(AGpsCallbacks* callbacks)
-{
-    LOGV("loc_eng_agps_init\n");
-    loc_eng_data.agps_status_cb = callbacks->status_cb;
-}
-
-static int loc_eng_agps_data_conn_open(const char* apn)
-{
-    int apn_len;
-    LOGD("loc_eng_agps_data_conn_open: %s\n", apn);
-
-    pthread_mutex_lock(&(loc_eng_data.deferred_action_mutex));
-
-    if (apn != NULL)
-    {
-        apn_len = strlen (apn);
-
-        if (apn_len >= sizeof(loc_eng_data.apn_name))
-        {
-            LOGD ("loc_eng_set_apn: error, apn name exceeds maximum lenght of 100 chars\n");
-            apn_len = sizeof(loc_eng_data.apn_name) - 1;
-        }
-
-        memcpy (loc_eng_data.apn_name, apn, apn_len);
-        loc_eng_data.apn_name[apn_len] = '\0';
-    }
-
-    /* hold a wake lock while events are pending for deferred_action_thread */
-    loc_eng_data.acquire_wakelock_cb();
-    loc_eng_data.deferred_action_flags |= DEFERRED_ACTION_AGPS_DATA_SUCCESS;
-    pthread_cond_signal(&(loc_eng_data.deferred_action_cond));
-    pthread_mutex_unlock(&(loc_eng_data.deferred_action_mutex));
-    return 0;
-}
-
-static int loc_eng_agps_data_conn_closed()
-{
-    LOGD("loc_eng_agps_data_conn_closed\n");
-    pthread_mutex_lock(&(loc_eng_data.deferred_action_mutex));
-    /* hold a wake lock while events are pending for deferred_action_thread */
-    loc_eng_data.acquire_wakelock_cb();
-    loc_eng_data.deferred_action_flags |= DEFERRED_ACTION_AGPS_DATA_CLOSED;
-    pthread_cond_signal(&(loc_eng_data.deferred_action_cond));
-    pthread_mutex_unlock(&(loc_eng_data.deferred_action_mutex));
-    return 0;
-}
-
-static int loc_eng_agps_data_conn_failed()
-{
-    LOGD("loc_eng_agps_data_conn_failed\n");
-
-    pthread_mutex_lock(&(loc_eng_data.deferred_action_mutex));
-    /* hold a wake lock while events are pending for deferred_action_thread */
-    loc_eng_data.acquire_wakelock_cb();
-    loc_eng_data.deferred_action_flags |= DEFERRED_ACTION_AGPS_DATA_FAILED;
-    pthread_cond_signal(&(loc_eng_data.deferred_action_cond));
-    pthread_mutex_unlock(&(loc_eng_data.deferred_action_mutex));
-    return 0;
-}
-
-static int set_agps_server()
-{
-    rpc_loc_ioctl_data_u_type       ioctl_data;
-    rpc_loc_server_info_s_type      *server_info_ptr;
-    boolean                         ret_val;
-    uint16                          port_temp;
-    unsigned char                   *b_ptr;
-
-    if (loc_eng_data.agps_server_host[0] == 0 || loc_eng_data.agps_server_port == 0)
-        return -1;
-
-    if (loc_eng_data.agps_server_address == 0) {
-        struct hostent* he = gethostbyname(loc_eng_data.agps_server_host);
-        if (he)
-            loc_eng_data.agps_server_address = *(uint32_t *)he->h_addr_list[0];
-    }
-    if (loc_eng_data.agps_server_address == 0)
-        return -1;
-
-    b_ptr = (unsigned char*) (&loc_eng_data.agps_server_address);
-
-
-    server_info_ptr = &(ioctl_data.rpc_loc_ioctl_data_u_type_u.server_addr);
-    ioctl_data.disc = RPC_LOC_IOCTL_SET_UMTS_SLP_SERVER_ADDR;
-    server_info_ptr->addr_type = RPC_LOC_SERVER_ADDR_URL;
-    server_info_ptr->addr_info.disc =  RPC_LOC_SERVER_ADDR_URL;
-
-#if (AMSS_VERSION==3200)
-    char   url[24];
-    memset(url, 0, sizeof(url));
-    snprintf(url, sizeof(url) - 1, "%d.%d.%d.%d:%d",
-            (*(b_ptr + 0)  & 0x000000ff), (*(b_ptr+1) & 0x000000ff),
-            (*(b_ptr + 2)  & 0x000000ff), (*(b_ptr+3) & 0x000000ff),
-            (loc_eng_data.agps_server_port & (0x0000ffff)));
-
-    server_info_ptr->addr_info.rpc_loc_server_addr_u_type_u.url.addr.addr_val = url;
-    server_info_ptr->addr_info.rpc_loc_server_addr_u_type_u.url.addr.addr_len = strlen(url);
-    LOGD ("set_agps_server, addr = %s\n", server_info_ptr->addr_info.rpc_loc_server_addr_u_type_u.url.addr.addr_val);
-#else
-    char* buf = server_info_ptr->addr_info.rpc_loc_server_addr_u_type_u.url.addr;
-    int buf_len = sizeof(server_info_ptr->addr_info.rpc_loc_server_addr_u_type_u.url.addr);
-    memset(buf, 0, buf_len);
-    snprintf(buf, buf_len - 1, "%d.%d.%d.%d:%d",
-            (*(b_ptr + 0)  & 0x000000ff), (*(b_ptr+1) & 0x000000ff),
-            (*(b_ptr + 2)  & 0x000000ff), (*(b_ptr+3) & 0x000000ff),
-            (loc_eng_data.agps_server_port & (0x0000ffff)));
-
-    server_info_ptr->addr_info.rpc_loc_server_addr_u_type_u.url.length = buf_len;
-    LOGD ("set_agps_server, addr = %s\n", buf);
-#endif
-
-    ret_val = loc_eng_ioctl (loc_eng_data.client_handle,
-                            RPC_LOC_IOCTL_SET_UMTS_SLP_SERVER_ADDR,
-                            &ioctl_data,
-                            LOC_IOCTL_DEFAULT_TIMEOUT,
-                            NULL /* No output information is expected*/);
-
-    if (ret_val != TRUE)
-    {
-        LOGD ("set_agps_server failed\n");
-        return -1;
-    }
-    else
-    {
-        LOGV ("set_agps_server successful\n");
-        return 0;
-    }
-}
-
-static int loc_eng_agps_set_server(AGpsType type, const char* hostname, int port)
-{
-    LOGD ("loc_eng_set_default_agps_server, type = %d, hostname = %s, port = %d\n", type, hostname, port);
-
-    if (type != AGPS_TYPE_SUPL)
-        return -1;
-
-    strncpy(loc_eng_data.agps_server_host, hostname, sizeof(loc_eng_data.agps_server_host) - 1);
-    loc_eng_data.agps_server_port = port;
-    return 0;
-}
-
-/*===========================================================================
-FUNCTION    loc_eng_delete_aiding_data_deferred_action
-
-DESCRIPTION
-   This is used to remove the aiding data when GPS engine is off.
-
-DEPENDENCIES
-   Assumes the aiding data type specified in GpsAidingData matches with
-   LOC API specification.
-
-RETURN VALUE
-   RPC_LOC_API_SUCCESS
-
-SIDE EFFECTS
-   N/A
-
-===========================================================================*/
-static void loc_eng_delete_aiding_data_deferred_action (void)
-{
-    // Currently, we only support deletion of all aiding data,
-    // since the Android defined aiding data mask matches with modem,
-    // so just pass them down without any translation
-    rpc_loc_ioctl_data_u_type          ioctl_data;
-    rpc_loc_assist_data_delete_s_type  *assist_data_ptr;
-    boolean                             ret_val;
-
-    ioctl_data.disc = RPC_LOC_IOCTL_DELETE_ASSIST_DATA;
-    assist_data_ptr = &(ioctl_data.rpc_loc_ioctl_data_u_type_u.assist_data_delete);
-    assist_data_ptr->type = loc_eng_data.aiding_data_for_deletion;
-    loc_eng_data.aiding_data_for_deletion = 0;
-
-    memset (&(assist_data_ptr->reserved), 0, sizeof (assist_data_ptr->reserved));
-
-    ret_val = loc_eng_ioctl (loc_eng_data.client_handle,
-                             RPC_LOC_IOCTL_DELETE_ASSIST_DATA ,
-                             &ioctl_data,
-                             LOC_IOCTL_DEFAULT_TIMEOUT,
-                             NULL);
-
-    LOGD("loc_eng_ioctl for aiding data deletion returned %d, 1 for success\n", ret_val);
-}
-
-/*===========================================================================
-FUNCTION    loc_eng_process_atl_deferred_action
-
-DESCRIPTION
-   This is used to inform the location engine of the processing status for
-   data connection open/close request.
-
-DEPENDENCIES
-   None
-
-RETURN VALUE
-   RPC_LOC_API_SUCCESS
-
-SIDE EFFECTS
-   N/A
-
-===========================================================================*/
-static void loc_eng_process_atl_deferred_action (int flags)
-{
-    rpc_loc_server_open_status_s_type  *conn_open_status_ptr;
-    rpc_loc_server_close_status_s_type *conn_close_status_ptr;
-    rpc_loc_ioctl_data_u_type           ioctl_data;
-    boolean                             ret_val;
-    int                                 agps_status = -1;
-
-    LOGV("loc_eng_process_atl_deferred_action, agps_status = %d\n", loc_eng_data.agps_status);
-
-    memset (&ioctl_data, 0, sizeof (rpc_loc_ioctl_data_u_type));
-
-    if (flags & DEFERRED_ACTION_AGPS_DATA_CLOSED)
-    {
-        ioctl_data.disc = RPC_LOC_IOCTL_INFORM_SERVER_CLOSE_STATUS;
-        conn_close_status_ptr = &(ioctl_data.rpc_loc_ioctl_data_u_type_u.conn_close_status);
-        conn_close_status_ptr->conn_handle = loc_eng_data.conn_handle;
-        conn_close_status_ptr->close_status = RPC_LOC_SERVER_CLOSE_SUCCESS;
-    }
-    else
-    {
-        ioctl_data.disc = RPC_LOC_IOCTL_INFORM_SERVER_OPEN_STATUS;
-        conn_open_status_ptr = &ioctl_data.rpc_loc_ioctl_data_u_type_u.conn_open_status;
-        conn_open_status_ptr->conn_handle = loc_eng_data.conn_handle;
-        if (flags & DEFERRED_ACTION_AGPS_DATA_SUCCESS)
-        {
-            conn_open_status_ptr->open_status = RPC_LOC_SERVER_OPEN_SUCCESS;
-            // Both buffer are of the same maximum size, and the source is null terminated
-            // strcpy (&(ioctl_data.rpc_loc_ioctl_data_u_type_u.conn_open_status.apn_name), &(loc_eng_data.apn_name));
-#if (AMSS_VERSION==3200)
-            conn_open_status_ptr->apn_name = loc_eng_data.apn_name;
-#else
-            memset(conn_open_status_ptr->apn_name, 0, sizeof(conn_open_status_ptr->apn_name));
-            strncpy(conn_open_status_ptr->apn_name, loc_eng_data.apn_name,
-                    sizeof(conn_open_status_ptr->apn_name) - 1);
-#endif
-            // Delay this so that PDSM ATL module will behave properly
-            sleep (1);
-            LOGD("loc_eng_ioctl for ATL with apn_name = %s\n", conn_open_status_ptr->apn_name);
-        }
-        else // data_connection_failed
-        {
-            conn_open_status_ptr->open_status = RPC_LOC_SERVER_OPEN_FAIL;
-        }
-        // Delay this so that PDSM ATL module will behave properly
-        sleep (1);
-    }
-
-    ret_val = loc_eng_ioctl (loc_eng_data.client_handle,
-                             ioctl_data.disc,
-                             &ioctl_data,
-                             LOC_IOCTL_DEFAULT_TIMEOUT,
-                             NULL);
-
-    LOGD("loc_eng_ioctl for ATL returned %d (1 for success)\n", ret_val);
-}
-
-/*===========================================================================
-FUNCTION    loc_eng_process_loc_event
-
-DESCRIPTION
-   This is used to process events received from the location engine.
-
-DEPENDENCIES
-   None
-
-RETURN VALUE
-   N/A
-
-SIDE EFFECTS
-   N/A
-
-===========================================================================*/
-static void loc_eng_process_loc_event (rpc_loc_event_mask_type loc_event,
-        rpc_loc_event_payload_u_type* loc_event_payload)
-{
-    if (loc_event & RPC_LOC_EVENT_PARSED_POSITION_REPORT)
-    {
-        loc_eng_report_position (&(loc_event_payload->rpc_loc_event_payload_u_type_u.parsed_location_report));
-    }
-
-    if (loc_event & RPC_LOC_EVENT_SATELLITE_REPORT)
-    {
-        loc_eng_report_sv (&(loc_event_payload->rpc_loc_event_payload_u_type_u.gnss_report));
-    }
-
-    if (loc_event & RPC_LOC_EVENT_STATUS_REPORT)
-    {
-        loc_eng_report_status (&(loc_event_payload->rpc_loc_event_payload_u_type_u.status_report));
-    }
-
-    if (loc_event & RPC_LOC_EVENT_NMEA_POSITION_REPORT)
-    {
-        loc_eng_report_nmea (&(loc_event_payload->rpc_loc_event_payload_u_type_u.nmea_report));
-    }
-
-    // Android XTRA interface supports only XTRA download
-    if (loc_event & RPC_LOC_EVENT_ASSISTANCE_DATA_REQUEST)
-    {
-        if (loc_event_payload->rpc_loc_event_payload_u_type_u.assist_data_request.event ==
-                RPC_LOC_ASSIST_DATA_PREDICTED_ORBITS_REQ)
-        {
-            LOGD ("loc_event_cb: xtra download requst");
-
-            // Call Registered callback
-            if (loc_eng_data.xtra_module_data.download_request_cb != NULL)
-            {
-                loc_eng_data.xtra_module_data.download_request_cb ();
-            }
-        }
-    }
-
-    if (loc_event & RPC_LOC_EVENT_IOCTL_REPORT)
-    {
-        // Process the received RPC_LOC_EVENT_IOCTL_REPORT
-        (void) loc_eng_ioctl_process_cb (loc_eng_data.client_handle,
-                                &(loc_event_payload->rpc_loc_event_payload_u_type_u.ioctl_report));
-    }
-
-    if (loc_event & RPC_LOC_EVENT_LOCATION_SERVER_REQUEST)
-    {
-        loc_eng_process_conn_request (&(loc_event_payload->rpc_loc_event_payload_u_type_u.loc_server_request));
-    }
-
-    loc_eng_ni_callback(loc_event, loc_event_payload);
-
-#if DEBUG_MOCK_NI == 1
-    // DEBUG only
-    if ((loc_event & RPC_LOC_EVENT_STATUS_REPORT) &&
-        loc_event_payload->rpc_loc_event_payload_u_type_u.status_report.
-        payload.rpc_loc_status_event_payload_u_type_u.engine_state
-        == RPC_LOC_ENGINE_STATE_OFF)
-    {
-        // Mock an NI request
-        pthread_t th;
-        pthread_create (&th, NULL, mock_ni, (void*) client_handle);
-    }
-#endif /* DEBUG_MOCK_NI == 1 */
-}
-
-/*===========================================================================
-FUNCTION loc_eng_process_deferred_action
-
-DESCRIPTION
-   Main routine for the thread to execute certain commands
-   that are not safe to be done from within an RPC callback.
-
-DEPENDENCIES
-   None
-
-RETURN VALUE
-   None
-
-SIDE EFFECTS
-   N/A
-
-===========================================================================*/
-static void loc_eng_process_deferred_action (void* arg)
-{
-    AGpsExtStatus      status;
-    status.size = sizeof(status);
-    status.type = AGPS_TYPE_SUPL;
-
-    LOGD("loc_eng_process_deferred_action started\n");
-
-    // make sure we do not run in background scheduling group
-    set_sched_policy(gettid(), SP_FOREGROUND);
-
-    // disable the GPS lock
-    LOGD("Setting GPS privacy lock to RPC_LOC_LOCK_NONE\n");
-    loc_eng_set_gps_lock(RPC_LOC_LOCK_NONE);
-
-    while (1)
-    {
-        GpsAidingData   aiding_data_for_deletion;
-        GpsStatusValue  engine_status;
-
-        rpc_loc_event_mask_type         loc_event;
-        rpc_loc_event_payload_u_type    loc_event_payload;
-
-        // Wait until we are signalled to do a deferred action, or exit
-        pthread_mutex_lock(&loc_eng_data.deferred_action_mutex);
-
-        // If we have an event we should process it immediately,
-        // otherwise wait until we are signalled
-        if (loc_eng_data.deferred_action_flags == 0) {
-            // do not hold a wake lock while waiting for an event...
-            loc_eng_data.release_wakelock_cb();
-            pthread_cond_wait(&loc_eng_data.deferred_action_cond,
-                                &loc_eng_data.deferred_action_mutex);
-            // but after we are signalled reacquire the wake lock
-            // until we are done processing the event.
-            loc_eng_data.acquire_wakelock_cb();
-        }
-
-        if (loc_eng_data.deferred_action_flags & DEFERRED_ACTION_QUIT)
-        {
-            pthread_mutex_unlock(&loc_eng_data.deferred_action_mutex);
-            break;
-        }
-
-        // copy anything we need before releasing the mutex
-        loc_event = loc_eng_data.loc_event;
-        if (loc_event != 0) {
-            memcpy(&loc_event_payload, &loc_eng_data.loc_event_payload, sizeof(loc_event_payload));
-            loc_eng_data.loc_event = 0;
-        }
-
-        int flags = loc_eng_data.deferred_action_flags;
-        loc_eng_data.deferred_action_flags = 0;
-        engine_status = loc_eng_data.agps_status;
-        aiding_data_for_deletion = loc_eng_data.aiding_data_for_deletion;
-        status.status = loc_eng_data.agps_status;
-        loc_eng_data.agps_status = 0;
-
-        // perform all actions after releasing the mutex to avoid blocking RPCs from the ARM9
-        pthread_mutex_unlock(&(loc_eng_data.deferred_action_mutex));
-
-        if (loc_event != 0) {
-            loc_eng_process_loc_event(loc_event, &loc_event_payload);
-        }
-
-        // send_delete_aiding_data must be done when GPS engine is off
-        if ((engine_status != GPS_STATUS_SESSION_BEGIN) && (aiding_data_for_deletion != 0))
-        {
-            loc_eng_delete_aiding_data_deferred_action ();
-        }
-
-        if (flags & (DEFERRED_ACTION_AGPS_DATA_SUCCESS |
-                     DEFERRED_ACTION_AGPS_DATA_CLOSED |
-                     DEFERRED_ACTION_AGPS_DATA_FAILED))
-        {
-            loc_eng_process_atl_deferred_action(flags);
-
-            pthread_mutex_lock(&(loc_eng_data.deferred_stop_mutex));
-            // work around problem with loc_eng_stop when AGPS requests are pending
-            // we defer stopping the engine until the AGPS request is done
-            loc_eng_data.agps_request_pending = false;
-            if (loc_eng_data.stop_request_pending)
-            {
-                LOGD ("handling deferred stop\n");
-                if (loc_stop_fix(loc_eng_data.client_handle) != RPC_LOC_API_SUCCESS)
-                {
-                    LOGD ("loc_stop_fix failed!\n");
-                }
-            }
-            pthread_mutex_unlock(&(loc_eng_data.deferred_stop_mutex));
-        }
-
-        if (status.status != 0 && loc_eng_data.agps_status_cb) {
-            loc_eng_data.agps_status_cb(&status);
-        }
-    }
-
-    // reenable the GPS lock
-    LOGD("Setting GPS privacy lock to RPC_LOC_LOCK_ALL\n");
-    loc_eng_set_gps_lock(RPC_LOC_LOCK_ALL);
-
-    LOGD("loc_eng_process_deferred_action thread exiting\n");
-    loc_eng_data.release_wakelock_cb();
-
-    loc_eng_data.deferred_action_thread = 0;
-}
-
-// for gps.c
-extern "C" const GpsInterface* get_gps_interface()
-{
-    return &sLocEngInterface;
-}
diff --git a/loc_api/libloc_api/loc_eng.h b/loc_api/libloc_api/loc_eng.h
deleted file mode 100644
index b855331..0000000
--- a/loc_api/libloc_api/loc_eng.h
+++ /dev/null
@@ -1,115 +0,0 @@
-/* Copyright (c) 2009,2011 The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above
- *       copyright notice, this list of conditions and the following
- *       disclaimer in the documentation and/or other materials provided
- *       with the distribution.
- *     * Neither the name of The Linux Foundation nor the names of its
- *       contributors may be used to endorse or promote products derived
- *       from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef LOC_ENG_H
-#define LOC_ENG_H
-
-// Define boolean type to be used by libgps on loc api module
-typedef unsigned char boolean;
-
-#ifndef TRUE
-#define TRUE 1
-#endif
-
-#ifndef FALSE
-#define FALSE 0
-#endif
-
-#include <loc_eng_ioctl.h>
-#include <loc_eng_xtra.h>
-#include <hardware/gps.h>
-
-#define LOC_IOCTL_DEFAULT_TIMEOUT 1000 // 1000 milli-seconds
-
-enum {
-    DEFERRED_ACTION_EVENT               = 0x01,
-    DEFERRED_ACTION_DELETE_AIDING       = 0x02,
-    DEFERRED_ACTION_AGPS_STATUS         = 0x04,
-    DEFERRED_ACTION_AGPS_DATA_SUCCESS   = 0x08,
-    DEFERRED_ACTION_AGPS_DATA_CLOSED    = 0x10,
-    DEFERRED_ACTION_AGPS_DATA_FAILED    = 0x20,
-    DEFERRED_ACTION_QUIT                = 0x40,
-};
-
-// Module data
-typedef struct
-{
-    rpc_loc_client_handle_type  client_handle;
-
-    gps_location_callback           location_cb;
-    gps_status_callback             status_cb;
-    gps_sv_status_callback          sv_status_cb;
-    agps_status_callback            agps_status_cb;
-    gps_nmea_callback               nmea_cb;
-    gps_ni_notify_callback          ni_notify_cb;
-    gps_acquire_wakelock            acquire_wakelock_cb;
-    gps_release_wakelock            release_wakelock_cb;
-    int                             agps_status;
-
-    // used to defer stopping the GPS engine until AGPS data calls are done
-    boolean                         agps_request_pending;
-    boolean                         stop_request_pending;
-    pthread_mutex_t                 deferred_stop_mutex;
-
-    loc_eng_xtra_data_s_type        xtra_module_data;
-
-    loc_eng_ioctl_data_s_type       ioctl_data;
-
-    // data from loc_event_cb
-    rpc_loc_event_mask_type         loc_event;
-    rpc_loc_event_payload_u_type    loc_event_payload;
-
-    // TBD:
-    char                            agps_server_host[256];
-    int                             agps_server_port;
-    uint32                          agps_server_address;
-    char                            apn_name[100];
-    int                             position_mode;
-    rpc_loc_server_connection_handle  conn_handle;
-
-    // GPS engine status
-    GpsStatusValue                  engine_status;
-
-    // Aiding data information to be deleted, aiding data can only be deleted when GPS engine is off
-    GpsAidingData                   aiding_data_for_deletion;
-
-    // Data variables used by deferred action thread
-    pthread_t                       deferred_action_thread;
-    // Mutex used by deferred action thread
-    pthread_mutex_t                 deferred_action_mutex;
-    // Condition variable used by deferred action thread
-    pthread_cond_t                  deferred_action_cond;
-
-    // flags for pending events for deferred action thread
-    int                             deferred_action_flags;
-} loc_eng_data_s_type;
-   
-extern loc_eng_data_s_type loc_eng_data;
-
-#endif // LOC_ENG_H
diff --git a/loc_api/libloc_api/loc_eng_ioctl.cpp b/loc_api/libloc_api/loc_eng_ioctl.cpp
deleted file mode 100644
index dc7b2c1..0000000
--- a/loc_api/libloc_api/loc_eng_ioctl.cpp
+++ /dev/null
@@ -1,354 +0,0 @@
-/* Copyright (c) 2009,2011 The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above
- *       copyright notice, this list of conditions and the following
- *       disclaimer in the documentation and/or other materials provided
- *       with the distribution.
- *     * Neither the name of The Linux Foundation nor the names of its
- *       contributors may be used to endorse or promote products derived
- *       from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#define LOG_NDDEBUG 0
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <errno.h>
-#include <unistd.h>
-#include <ctype.h>
-#include <math.h>
-#include <pthread.h>
-
-#include <rpc/rpc.h>
-#include <loc_api_rpc_glue.h>
-
-#include <hardware/gps.h>
-
-#include <loc_eng.h>
-
-#define LOG_TAG "lib_locapi"
-#include <utils/Log.h>
-
-// comment this out to enable logging
-// #undef LOGD
-// #define LOGD(...) {}
-
-// Function declarations
-static boolean loc_eng_ioctl_setup_cb(
-    rpc_loc_client_handle_type    handle,
-    rpc_loc_ioctl_e_type          ioctl_type
-);
-
-static boolean loc_eng_ioctl_wait_cb(
-    int                            timeout_msec,  // Timeout in this number of msec
-    rpc_loc_ioctl_callback_s_type *cb_data_ptr    // Output parameter for IOCTL calls
-);
-
-/*===========================================================================
-
-FUNCTION    loc_eng_ioctl
-
-DESCRIPTION
-   This function calls loc_ioctl and waits for the callback result before
-   returning back to the user.
-
-DEPENDENCIES
-   N/A
-
-RETURN VALUE
-   TRUE                 if successful
-   FALSE                if failed
-
-SIDE EFFECTS
-   N/A
-
-===========================================================================*/
-boolean loc_eng_ioctl(
-    rpc_loc_client_handle_type           handle,
-    rpc_loc_ioctl_e_type                 ioctl_type,
-    rpc_loc_ioctl_data_u_type*           ioctl_data_ptr,
-    uint32                               timeout_msec,
-    rpc_loc_ioctl_callback_s_type       *cb_data_ptr
-    )
-{
-    boolean                    ret_val;
-    int                        rpc_ret_val;
-    loc_eng_ioctl_data_s_type *ioctl_cb_data_ptr;
-
-    LOGV ("loc_eng_ioctl: client = %d, ioctl_type = %d, cb_data =0x%x\n", (int32) handle, ioctl_type, (uint32) cb_data_ptr);
-
-    ioctl_cb_data_ptr = &(loc_eng_data.ioctl_data);
-    // Select the callback we are waiting for
-    ret_val = loc_eng_ioctl_setup_cb (handle, ioctl_type);
-
-    if (ret_val == TRUE) 
-    {
-        rpc_ret_val =  loc_ioctl (handle,
-                                    ioctl_type,
-                                    ioctl_data_ptr);
-
-        LOGV ("loc_eng_ioctl: loc_ioctl returned %d \n", rpc_ret_val);
-
-        if (rpc_ret_val == RPC_LOC_API_SUCCESS)
-        {
-            // Wait for the callback of loc_ioctl
-            ret_val = loc_eng_ioctl_wait_cb (timeout_msec, cb_data_ptr);
-        }
-        else
-        {
-            ret_val = FALSE;
-        }
-    }
-
-    // Reset the state when we are done
-    pthread_mutex_lock(&ioctl_cb_data_ptr->cb_data_mutex);
-    ioctl_cb_data_ptr->cb_is_selected = FALSE;
-    ioctl_cb_data_ptr->cb_is_waiting  = FALSE;
-    ioctl_cb_data_ptr->cb_has_arrived = FALSE;
-    pthread_mutex_unlock(&ioctl_cb_data_ptr->cb_data_mutex);
-
-    return ret_val;
-}
-
-
-/*===========================================================================
-
-FUNCTION    loc_eng_ioctl_setup_cb
-
-DESCRIPTION
-   Selects which callback is going to be waited for
-
-DEPENDENCIES
-   N/A
-
-RETURN VALUE
-   TRUE                 if successful
-   FALSE                if failed
-
-SIDE EFFECTS
-   N/A
-
-===========================================================================*/
-static boolean loc_eng_ioctl_setup_cb(
-    rpc_loc_client_handle_type    handle,
-    rpc_loc_ioctl_e_type          ioctl_type
-    )
-{
-    boolean ret_val;
-    loc_eng_ioctl_data_s_type *ioctl_cb_data_ptr;
-
-    ioctl_cb_data_ptr = &(loc_eng_data.ioctl_data);
-
-    pthread_mutex_lock(&ioctl_cb_data_ptr->cb_data_mutex);
-    if (ioctl_cb_data_ptr->cb_is_selected == TRUE)
-    {
-        LOGD ("loc_eng_ioctl_setup_cb: ERROR, another ioctl in progress \n");
-        ret_val = FALSE;
-    }
-    else
-    {
-        ioctl_cb_data_ptr->cb_is_selected = TRUE;
-        ioctl_cb_data_ptr->cb_is_waiting  = FALSE;
-        ioctl_cb_data_ptr->cb_has_arrived = FALSE;
-        ioctl_cb_data_ptr->client_handle  = handle;
-        ioctl_cb_data_ptr->ioctl_type     = ioctl_type;
-        memset (&(ioctl_cb_data_ptr->cb_payload), 0, sizeof (rpc_loc_ioctl_callback_s_type));
-        ret_val = TRUE;
-    }
-    pthread_mutex_unlock(&ioctl_cb_data_ptr->cb_data_mutex);
-
-    return ret_val;
-}
-
-/*===========================================================================
-
-FUNCTION    loc_eng_ioctl_wait_cb
-
-DESCRIPTION
-   Waits for a selected callback. The wait expires in timeout_msec.
-
-   If the function is called before an existing wait has finished, it will
-   immediately return EBUSY.
-
-DEPENDENCIES
-   N/A
-
-RETURN VALUE
-   TRUE                 if successful
-   FALSE                if failed
-
-SIDE EFFECTS
-   N/A
-
-===========================================================================*/
-boolean loc_eng_ioctl_wait_cb(
-    int                            timeout_msec,  // Timeout in this number of msec
-    rpc_loc_ioctl_callback_s_type *cb_data_ptr
-    )
-{
-    boolean ret_val = FALSE; // the return value of this function
-    int rc;                  // return code from pthread calls
-
-    struct timeval present_time;
-    struct timespec expire_time;
-    loc_eng_ioctl_data_s_type *ioctl_cb_data_ptr;
-
-    ioctl_cb_data_ptr = &(loc_eng_data.ioctl_data);
-
-    pthread_mutex_lock(&ioctl_cb_data_ptr->cb_data_mutex);
-
-    do {
-        if (ioctl_cb_data_ptr->cb_is_selected == FALSE)
-        {
-            LOGD ("loc_eng_ioctl_wait_cb: ERROR called when cb_is_waiting is set to FALSE \n");
-            ret_val = FALSE;
-            break;
-        }
-
-        // Calculate absolute expire time
-        gettimeofday(&present_time, NULL);
-        expire_time.tv_sec  = present_time.tv_sec;
-        expire_time.tv_sec  +=  timeout_msec / 1000;
-        if ((present_time.tv_usec + timeout_msec) >= 1000)
-        {
-            expire_time.tv_sec += 1;
-        }
-        expire_time.tv_nsec = (present_time.tv_usec + timeout_msec) % 1000 * 1000;
-
-        // Special case where callback is issued before loc_ioctl ever returns
-        if (ioctl_cb_data_ptr->cb_has_arrived == TRUE)
-        {
-            LOGD ("loc_eng_ioctl_wait_cb: cb has arrived without waiting \n");
-            ret_val = TRUE;
-            break;
-        }
-   
-        ioctl_cb_data_ptr->cb_is_waiting = TRUE;
-        // Wait for the callback until timeout expires
-        rc = pthread_cond_timedwait(&ioctl_cb_data_ptr->cb_arrived_cond,
-                                    &ioctl_cb_data_ptr->cb_data_mutex,
-                                    &expire_time);
-
-        if (rc == 0)
-        {
-            ret_val = TRUE;
-        }
-        else
-        {
-            ret_val = FALSE;
-        }
-
-        LOGV ("loc_eng_ioctl_wait_cb: pthread_cond_timedwait returned %d\n", rc);
-
-    } while (0);
-
-    // Process the ioctl callback data when IOCTL is successful
-    if (ret_val == TRUE)
-    {
-        ioctl_cb_data_ptr = &(loc_eng_data.ioctl_data);
-        if (ioctl_cb_data_ptr->cb_payload.status == RPC_LOC_API_SUCCESS)
-        {
-            ret_val = TRUE;
-            if (cb_data_ptr != NULL)
-            {
-                memcpy (cb_data_ptr,
-                        &(ioctl_cb_data_ptr->cb_payload),
-                        sizeof (rpc_loc_ioctl_callback_s_type));
-            }
-        }
-        else
-        {
-            ret_val = FALSE;
-        }
-    }
-
-    pthread_mutex_unlock(&ioctl_cb_data_ptr->cb_data_mutex);
-
-    LOGV ("loc_eng_ioctl_wait_cb: returned %d\n", ret_val);
-    return ret_val;
-}
-
-/*===========================================================================
-
-FUNCTION    loc_eng_ioctl_process_cb
-
-DESCRIPTION
-   This function process the IOCTL callback, parameter specifies the client 
-   that receives the IOCTL callback.
-
-DEPENDENCIES
-   N/A
-
-RETURN VALUE
-   TRUE                 if successful
-   FALSE                if failed
-
-SIDE EFFECTS
-   N/A
-
-===========================================================================*/
-boolean loc_eng_ioctl_process_cb (
-    rpc_loc_client_handle_type           client_handle,
-    const rpc_loc_ioctl_callback_s_type *cb_data_ptr
-    )
-{
-    boolean ret_val = FALSE; // the return value of this function
-    loc_eng_ioctl_data_s_type *ioctl_cb_data_ptr;
-    ioctl_cb_data_ptr = &(loc_eng_data.ioctl_data);
-
-    pthread_mutex_lock(&ioctl_cb_data_ptr->cb_data_mutex);
-    if (client_handle != ioctl_cb_data_ptr->client_handle)
-    {
-        LOGD ("loc_eng_ioctl_process_cb: client handle mismatch, received = %d, expected = %d \n",
-                (int32) client_handle, (int32) ioctl_cb_data_ptr->client_handle);
-        ret_val = FALSE;
-    }
-    else if (cb_data_ptr->type != ioctl_cb_data_ptr->ioctl_type)
-    {
-        LOGD ("loc_eng_ioctl_process_cb: ioctl type mismatch, received = %d, expected = %d \n",
-                 cb_data_ptr->type, ioctl_cb_data_ptr->ioctl_type);
-        ret_val = FALSE;
-    }
-    else // both matches
-    {
-        memcpy (&(ioctl_cb_data_ptr->cb_payload),
-                cb_data_ptr,
-                sizeof (rpc_loc_ioctl_callback_s_type));
-
-        ioctl_cb_data_ptr->cb_has_arrived = TRUE;
-
-        LOGV ("loc_eng_ioctl_process_cb: callback arrived for client = %d, ioctl = %d, status = %d\n",
-                (int32) ioctl_cb_data_ptr->client_handle, ioctl_cb_data_ptr->ioctl_type,
-                (int32) ioctl_cb_data_ptr->cb_payload.status);
-
-        ret_val = TRUE;
-    }
-
-    pthread_mutex_unlock(&ioctl_cb_data_ptr->cb_data_mutex);
-
-    // Signal the waiting thread that callback has arrived
-    if (ret_val == TRUE)
-    {
-        pthread_cond_signal (&ioctl_cb_data_ptr->cb_arrived_cond);
-    }
-
-    return ret_val;
-}
diff --git a/loc_api/libloc_api/loc_eng_ioctl.h b/loc_api/libloc_api/loc_eng_ioctl.h
deleted file mode 100644
index b819125..0000000
--- a/loc_api/libloc_api/loc_eng_ioctl.h
+++ /dev/null
@@ -1,69 +0,0 @@
-/* Copyright (c) 2009,2011 The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above
- *       copyright notice, this list of conditions and the following
- *       disclaimer in the documentation and/or other materials provided
- *       with the distribution.
- *     * Neither the name of The Linux Foundation nor the names of its
- *       contributors may be used to endorse or promote products derived
- *       from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef LOC_ENG_IOCTL_H
-#define LOC_ENG_IOCTL_H
-
-// Module data
-typedef struct loc_eng_ioctl_data_s_type
-{
-    // We are waiting for an ioctl callback
-    boolean                       cb_is_selected;
-    // The thread has been put in a wait state for an ioctl callback
-    boolean                       cb_is_waiting;
-    // Loc client handle that is waiting for the callback
-    rpc_loc_client_handle_type    client_handle;
-    // IOCTL type that the loc client is waiting for
-    rpc_loc_ioctl_e_type          ioctl_type;
-    // The IOCLT report has arrived for the waiting client
-    boolean                       cb_has_arrived;
-    // The payload for the RPC_LOC_EVENT_IOCTL_REPORT
-    rpc_loc_ioctl_callback_s_type cb_payload;
-    // Mutex to access this data structure
-    pthread_mutex_t               cb_data_mutex;
-    // LOC ioctl callback arrived mutex
-    pthread_cond_t                cb_arrived_cond;
-} loc_eng_ioctl_data_s_type;
-
-
-extern boolean loc_eng_ioctl
-(
-    rpc_loc_client_handle_type           handle,
-    rpc_loc_ioctl_e_type                 ioctl_type,
-    rpc_loc_ioctl_data_u_type*           ioctl_data_ptr,
-    uint32                               timeout_msec,
-    rpc_loc_ioctl_callback_s_type       *cb_data_ptr
-);
-
-extern boolean loc_eng_ioctl_process_cb 
-(
-    rpc_loc_client_handle_type           client_handle,
-    const rpc_loc_ioctl_callback_s_type *cb_data_ptr
-);
-#endif // LOC_ENG_IOCTL_H
diff --git a/loc_api/libloc_api/loc_eng_ni.cpp b/loc_api/libloc_api/loc_eng_ni.cpp
deleted file mode 100644
index 11d7aba..0000000
--- a/loc_api/libloc_api/loc_eng_ni.cpp
+++ /dev/null
@@ -1,609 +0,0 @@
-/* Copyright (c) 2009,2011 The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above
- *       copyright notice, this list of conditions and the following
- *       disclaimer in the documentation and/or other materials provided
- *       with the distribution.
- *     * Neither the name of The Linux Foundation nor the names of its
- *       contributors may be used to endorse or promote products derived
- *       from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#define LOG_NDDEBUG 0
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <pthread.h>
-#include <string.h>
-#include <ctype.h>
-#include <unistd.h>
-#include <time.h>
-
-#include <rpc/rpc.h>
-#include <loc_api_rpc_glue.h>
-#include <loc_eng.h>
-#include <loc_eng_ni.h>
-
-#define LOG_TAG "lib_locapi"
-#include <utils/Log.h>
-
-// comment this out to enable logging
-// #undef LOGD
-// #define LOGD(...) {}
-
-/*=============================================================================
- *
- *                             DATA DECLARATION
- *
- *============================================================================*/
-
-const GpsNiInterface sLocEngNiInterface =
-{
-    sizeof(GpsNiInterface),
-    loc_eng_ni_init,
-    loc_eng_ni_respond,
-};
-
-boolean loc_eng_ni_data_init = FALSE;
-loc_eng_ni_data_s_type loc_eng_ni_data;
-
-extern loc_eng_data_s_type loc_eng_data;
-
-/*=============================================================================
- *
- *                             FUNCTION DECLARATIONS
- *
- *============================================================================*/
-
-/*===========================================================================
-
-FUNCTION respond_from_enum
-
-DESCRIPTION
-   Returns the name of the response
-
-RETURN VALUE
-   response name string
-
-===========================================================================*/
-static const char* respond_from_enum(rpc_loc_ni_user_resp_e_type resp)
-{
-    switch (resp)
-    {
-    case RPC_LOC_NI_LCS_NOTIFY_VERIFY_ACCEPT:
-        return "accept";
-    case RPC_LOC_NI_LCS_NOTIFY_VERIFY_DENY:
-        return "deny";
-    case RPC_LOC_NI_LCS_NOTIFY_VERIFY_NORESP:
-        return "no response";
-    default:
-        return NULL;
-    }
-}
-
-/*===========================================================================
-
-FUNCTION loc_ni_respond
-
-DESCRIPTION
-   Displays the NI request and awaits user input. If a previous request is
-   in session, the new one is handled using sys.ni_default_response (if exists);
-   otherwise, it is denied.
-
-DEPENDENCY
-   Do not lock the data by mutex loc_ni_lock
-
-RETURN VALUE
-   none
-
-===========================================================================*/
-static void loc_ni_respond(rpc_loc_ni_user_resp_e_type resp,
-                    const rpc_loc_ni_event_s_type *request_pass_back
-)
-{
-    LOGD("Sending NI response: %s\n", respond_from_enum(resp));
-
-    rpc_loc_ioctl_data_u_type data;
-    rpc_loc_ioctl_callback_s_type callback_payload;
-
-    memcpy(&data.rpc_loc_ioctl_data_u_type_u.user_verify_resp.ni_event_pass_back,
-            request_pass_back, sizeof (rpc_loc_ni_event_s_type));
-    data.rpc_loc_ioctl_data_u_type_u.user_verify_resp.user_resp = resp;
-
-    loc_eng_ioctl(
-            loc_eng_data.client_handle,
-            RPC_LOC_IOCTL_INFORM_NI_USER_RESPONSE,
-            &data,
-            LOC_IOCTL_DEFAULT_TIMEOUT,
-            &callback_payload
-    );
-}
-
-/*===========================================================================
-
-FUNCTION loc_ni_fill_notif_verify_type
-
-DESCRIPTION
-   Fills need_notify, need_verify, etc.
-
-RETURN VALUE
-   none
-
-===========================================================================*/
-static boolean loc_ni_fill_notif_verify_type(GpsNiNotification *notif,
-      rpc_loc_ni_notify_verify_e_type notif_priv)
-{
-    notif->notify_flags       = 0;
-    notif->default_response   = GPS_NI_RESPONSE_NORESP;
-
-    switch (notif_priv)
-    {
-    case RPC_LOC_NI_USER_NO_NOTIFY_NO_VERIFY:
-        notif->notify_flags = 0;
-        break;
-
-    case RPC_LOC_NI_USER_NOTIFY_ONLY:
-        notif->notify_flags = GPS_NI_NEED_NOTIFY;
-        break;
-
-    case RPC_LOC_NI_USER_NOTIFY_VERIFY_ALLOW_NO_RESP:
-        notif->notify_flags = GPS_NI_NEED_NOTIFY | GPS_NI_NEED_VERIFY;
-        notif->default_response = GPS_NI_RESPONSE_ACCEPT;
-        break;
-
-    case RPC_LOC_NI_USER_NOTIFY_VERIFY_NOT_ALLOW_NO_RESP:
-        notif->notify_flags = GPS_NI_NEED_NOTIFY | GPS_NI_NEED_VERIFY;
-        notif->default_response = GPS_NI_RESPONSE_DENY;
-        break;
-
-    case RPC_LOC_NI_USER_PRIVACY_OVERRIDE:
-        notif->notify_flags = GPS_NI_PRIVACY_OVERRIDE;
-        break;
-
-    default:
-        return FALSE;
-    }
-
-    return TRUE;
-}
-
-/*===========================================================================
-
-FUNCTION hexcode
-
-DESCRIPTION
-   Converts a binary array into a Hex string. E.g., 1F 00 3F --> "1F003F"
-
-RETURN VALUE
-   bytes encoded
-
-===========================================================================*/
-static int hexcode(char *hexstring, int string_size, const char *data, int data_size)
-{
-    int i;
-    for (i = 0; i < data_size; i++)
-    {
-        char ch = data[i];
-        if (i*2 + 3 <= string_size)
-        {
-            snprintf(&hexstring[i*2], 3, "%02X", ch);
-        }
-        else {
-            break;
-        }
-    }
-    return i;
-}
-
-static GpsNiEncodingType convert_encoding_type(int loc_encoding)
-{
-    GpsNiEncodingType enc = GPS_ENC_UNKNOWN;
-
-    switch (loc_encoding)
-    {
-    case RPC_LOC_NI_SUPL_UTF8:
-        enc = GPS_ENC_SUPL_UTF8;
-        break;
-    case RPC_LOC_NI_SUPL_UCS2:
-        enc = GPS_ENC_SUPL_UCS2;
-        break;
-    case RPC_LOC_NI_SUPL_GSM_DEFAULT:
-        enc = GPS_ENC_SUPL_GSM_DEFAULT;
-        break;
-    default:
-        break;
-    }
-
-    return enc;
-}
-
-/*===========================================================================
-
-FUNCTION loc_ni_request_handler
-
-DESCRIPTION
-   Displays the NI request and awaits user input. If a previous request is
-   in session, it is ignored.
-
-RETURN VALUE
-   none
-
-===========================================================================*/
-static void loc_ni_request_handler(const char *msg, const rpc_loc_ni_event_s_type *ni_req)
-{
-    GpsNiNotification notif;
-    notif.size = sizeof(notif);
-    strlcpy(notif.text, "[text]", sizeof notif.text);    // defaults
-    strlcpy(notif.requestor_id, "[requestor id]", sizeof notif.requestor_id);
-
-    /* If busy, use default or deny */
-    if (loc_eng_ni_data.notif_in_progress)
-    {
-#if 0
-        /* Cannot be here because the current thread is in RPC client */
-        /* XXX Consider adding an event queue to process overlapped NI requests */
-        loc_ni_user_resp_e_type response =
-            sys.ni_default_resp == 1 /* accept */ ?
-                    LOC_NI_LCS_NOTIFY_VERIFY_ACCEPT :
-                    LOC_NI_LCS_NOTIFY_VERIFY_DENY;
-
-        loc_ni_respond(response, ni_req); */
-#endif
-        LOGW("loc_ni_request_handler, notification in progress, new NI request ignored, type: %d",
-                ni_req->event);
-    }
-    else {
-        /* Print notification */
-        LOGD("NI Notification: %s, event: %d", msg, ni_req->event);
-
-        pthread_mutex_lock(&loc_eng_ni_data.loc_ni_lock);
-
-        /* Save request */
-        memcpy(&loc_eng_ni_data.loc_ni_request, ni_req, sizeof loc_eng_ni_data.loc_ni_request);
-
-        /* Set up NI response waiting */
-        loc_eng_ni_data.notif_in_progress = TRUE;
-        loc_eng_ni_data.current_notif_id = abs(rand());
-
-        /* Fill in notification */
-        notif.notification_id = loc_eng_ni_data.current_notif_id;
-
-        const rpc_loc_ni_vx_notify_verify_req_s_type *vx_req;
-        const rpc_loc_ni_supl_notify_verify_req_s_type *supl_req;
-        const rpc_loc_ni_umts_cp_notify_verify_req_s_type *umts_cp_req;
-
-        switch (ni_req->event)
-        {
-            case RPC_LOC_NI_EVENT_VX_NOTIFY_VERIFY_REQ:
-                vx_req = &ni_req->payload.rpc_loc_ni_event_payload_u_type_u.vx_req;
-                notif.ni_type     = GPS_NI_TYPE_VOICE;
-                notif.timeout     = LOC_NI_NO_RESPONSE_TIME; // vx_req->user_resp_timer_val;
-                memset(notif.extras, 0, sizeof notif.extras);
-                memset(notif.text, 0, sizeof notif.text);
-                memset(notif.requestor_id, 0, sizeof notif.requestor_id);
-
-                // Requestor ID
-                hexcode(notif.requestor_id, sizeof notif.requestor_id,
-                        vx_req->requester_id.requester_id,
-                        vx_req->requester_id.requester_id_length);
-
-                notif.text_encoding = 0; // No text and no encoding
-                notif.requestor_id_encoding = convert_encoding_type(vx_req->encoding_scheme);
-
-                // Set default_response & notify_flags
-                loc_ni_fill_notif_verify_type(&notif, vx_req->notification_priv_type);
-
-                break;
-
-            case RPC_LOC_NI_EVENT_UMTS_CP_NOTIFY_VERIFY_REQ:
-                umts_cp_req = &ni_req->payload.rpc_loc_ni_event_payload_u_type_u.umts_cp_req;
-                notif.ni_type     = GPS_NI_TYPE_UMTS_CTRL_PLANE;
-                notif.timeout     = LOC_NI_NO_RESPONSE_TIME; // umts_cp_req->user_response_timer;
-                memset(notif.extras, 0, sizeof notif.extras);
-                memset(notif.text, 0, sizeof notif.text);
-                memset(notif.requestor_id, 0, sizeof notif.requestor_id);
-
-                // Stores notification text
-                hexcode(notif.text, sizeof notif.text,
-#if (AMSS_VERSION==3200)
-                        umts_cp_req->notification_text.notification_text_val,
-#else
-                        umts_cp_req->notification_text,
-#endif
-                        umts_cp_req->notification_length);
-
-                // Stores requestor ID
-                hexcode(notif.requestor_id, sizeof notif.requestor_id,
-#if (AMSS_VERSION==3200)
-                        umts_cp_req->requestor_id.requestor_id_string.requestor_id_string_val,
-#else
-                        umts_cp_req->requestor_id.requestor_id_string,
-#endif
-                        umts_cp_req->requestor_id.string_len);
-
-                notif.text_encoding = convert_encoding_type(umts_cp_req->datacoding_scheme);
-                notif.requestor_id_encoding = convert_encoding_type(umts_cp_req->datacoding_scheme);
-
-                // Set default_response & notify_flags
-                loc_ni_fill_notif_verify_type(&notif, umts_cp_req->notification_priv_type);
-
-                break;
-
-            case RPC_LOC_NI_EVENT_SUPL_NOTIFY_VERIFY_REQ:
-                supl_req = &ni_req->payload.rpc_loc_ni_event_payload_u_type_u.supl_req;
-                notif.ni_type     = GPS_NI_TYPE_UMTS_SUPL;
-                notif.timeout     = LOC_NI_NO_RESPONSE_TIME; // supl_req->user_response_timer;
-                memset(notif.extras, 0, sizeof notif.extras);
-                memset(notif.text, 0, sizeof notif.text);
-                memset(notif.requestor_id, 0, sizeof notif.requestor_id);
-
-                // Client name
-                if (supl_req->flags & RPC_LOC_NI_CLIENT_NAME_PRESENT)
-                {
-                    hexcode(notif.text, sizeof notif.text,
-#if (AMSS_VERSION==3200)
-                            supl_req->client_name.client_name_string.client_name_string_val,   /* buffer */
-#else
-                            supl_req->client_name.client_name_string,                          /* buffer */
-#endif
-                            supl_req->client_name.string_len                                   /* length */
-                    );
-                    LOGD("SUPL NI: client_name: %s len=%d", notif.text, supl_req->client_name.string_len);
-                } else {
-                    LOGD("SUPL NI: client_name not present.");
-                }
-
-                // Requestor ID
-                if (supl_req->flags & RPC_LOC_NI_REQUESTOR_ID_PRESENT)
-                {
-                    hexcode(notif.requestor_id, sizeof notif.requestor_id,
-#if (AMSS_VERSION==3200)
-                            supl_req->requestor_id.requestor_id_string.requestor_id_string_val,  /* buffer */
-#else
-                            supl_req->requestor_id.requestor_id_string,                          /* buffer */
-#endif
-                            supl_req->requestor_id.string_len                                    /* length */
-                    );
-                    LOGD("SUPL NI: requestor_id: %s len=%d", notif.requestor_id, supl_req->requestor_id.string_len);
-                } else {
-                    LOGD("SUPL NI: requestor_id not present.");
-                }
-
-                // Encoding type
-                if (supl_req->flags & RPC_LOC_NI_ENCODING_TYPE_PRESENT)
-                {
-                    notif.text_encoding = convert_encoding_type(supl_req->datacoding_scheme);
-                    notif.requestor_id_encoding = convert_encoding_type(supl_req->datacoding_scheme);
-                } else {
-                    notif.text_encoding = notif.requestor_id_encoding = GPS_ENC_UNKNOWN;
-                }
-
-                // Set default_response & notify_flags
-                loc_ni_fill_notif_verify_type(&notif, ni_req->payload.rpc_loc_ni_event_payload_u_type_u.supl_req.notification_priv_type);
-
-                break;
-
-            default:
-                LOGE("loc_ni_request_handler, unknown request event: %d", ni_req->event);
-                return;
-        }
-
-        /* Log requestor ID and text for debugging */
-        LOGI("Notification: notif_type: %d, timeout: %d, default_resp: %d", notif.ni_type, notif.timeout, notif.default_response);
-        LOGI("              requestor_id: %s (encoding: %d)", notif.requestor_id, notif.requestor_id_encoding);
-        LOGI("              text: %s text (encoding: %d)", notif.text, notif.text_encoding);
-
-        /* For robustness, always sets a timeout to clear up the notification status, even though
-        * the OEM layer in java does not do so.
-        **/
-        loc_eng_ni_data.response_time_left = 5 + (notif.timeout != 0 ? notif.timeout : LOC_NI_NO_RESPONSE_TIME);
-        LOGI("Automatically sends 'no response' in %d seconds (to clear status)\n", loc_eng_ni_data.response_time_left);
-
-        pthread_mutex_unlock(&loc_eng_ni_data.loc_ni_lock);
-
-        /* Notify callback */
-        if (loc_eng_data.ni_notify_cb != NULL)
-        {
-            loc_eng_data.ni_notify_cb(&notif);
-        }
-    }
-}
-
-/*===========================================================================
-
-FUNCTION loc_ni_process_user_response
-
-DESCRIPTION
-   Handles user input from the UI
-
-RETURN VALUE
-   error code (0 for successful, -1 for error)
-
-===========================================================================*/
-int loc_ni_process_user_response(GpsUserResponseType userResponse)
-{
-    LOGD("NI response from UI: %d", userResponse);
-
-    rpc_loc_ni_user_resp_e_type resp;
-    switch (userResponse)
-    {
-        case GPS_NI_RESPONSE_ACCEPT:
-            resp = RPC_LOC_NI_LCS_NOTIFY_VERIFY_ACCEPT;
-            break;
-        case GPS_NI_RESPONSE_DENY:
-            resp = RPC_LOC_NI_LCS_NOTIFY_VERIFY_DENY;
-            break;
-        case GPS_NI_RESPONSE_NORESP:
-            resp = RPC_LOC_NI_LCS_NOTIFY_VERIFY_NORESP;
-            break;
-        default:
-            return -1;
-    }
-
-    loc_ni_respond(resp, &loc_eng_ni_data.loc_ni_request);
-
-    /* Make the NI respond */
-    pthread_mutex_lock(&loc_eng_ni_data.loc_ni_lock);
-    loc_eng_ni_data.notif_in_progress = FALSE;
-    loc_eng_ni_data.response_time_left = 0;
-    loc_eng_ni_data.current_notif_id = -1;
-    pthread_mutex_unlock(&loc_eng_ni_data.loc_ni_lock);
-
-    return 0;
-}
-
-/*===========================================================================
-
-FUNCTION loc_eng_ni_callback
-
-DESCRIPTION
-   Loc API callback handler
-
-RETURN VALUE
-   error code (0 for success)
-
-===========================================================================*/
-int loc_eng_ni_callback (
-      rpc_loc_event_mask_type               loc_event,              /* event mask           */
-      const rpc_loc_event_payload_u_type*   loc_event_payload       /* payload              */
-)
-{
-    int rc = 0;
-    const rpc_loc_ni_event_s_type *ni_req = &loc_event_payload->rpc_loc_event_payload_u_type_u.ni_request;
-    if (loc_event == RPC_LOC_EVENT_NI_NOTIFY_VERIFY_REQUEST)
-    {
-        switch (ni_req->event)
-        {
-            case RPC_LOC_NI_EVENT_VX_NOTIFY_VERIFY_REQ:
-                LOGI("VX Notification");
-                loc_ni_request_handler("VX Notify", ni_req);
-                break;
-
-            case RPC_LOC_NI_EVENT_UMTS_CP_NOTIFY_VERIFY_REQ:
-                LOGI("UMTS CP Notification\n");
-                loc_ni_request_handler("UMTS CP Notify", ni_req);
-                break;
-
-            case RPC_LOC_NI_EVENT_SUPL_NOTIFY_VERIFY_REQ:
-                LOGI("SUPL Notification\n");
-                loc_ni_request_handler("SUPL Notify", ni_req);
-                break;
-
-            default:
-                LOGE("Unknown NI event: %x\n", (int) ni_req->event);
-                break;
-        }
-    }
-    return rc;
-}
-
-/*===========================================================================
-
-FUNCTION loc_ni_thread_proc
-
-===========================================================================*/
-static void loc_ni_thread_proc(void *unused)
-{
-    LOGI("Starting Loc NI thread...\n");
-
-    while (1)
-    {
-        /* wakes up every second to check timed out requests */
-        sleep(1);
-
-        pthread_mutex_lock(&loc_eng_ni_data.loc_ni_lock);
-
-        if (loc_eng_ni_data.notif_in_progress && loc_eng_ni_data.response_time_left > 0)
-        {
-            loc_eng_ni_data.response_time_left--;
-            if (loc_eng_ni_data.response_time_left <= 0)
-            {
-                loc_ni_respond(RPC_LOC_NI_LCS_NOTIFY_VERIFY_NORESP, &loc_eng_ni_data.loc_ni_request);
-                loc_eng_ni_data.notif_in_progress = FALSE;
-            }
-        }
-
-        pthread_mutex_unlock(&loc_eng_ni_data.loc_ni_lock);
-    } /* while (1) */
-}
-
-/*===========================================================================
-FUNCTION    loc_eng_ni_init
-
-DESCRIPTION
-   This function initializes the NI interface
-
-DEPENDENCIES
-   NONE
-
-RETURN VALUE
-   None
-
-SIDE EFFECTS
-   N/A
-
-===========================================================================*/
-void loc_eng_ni_init(GpsNiCallbacks *callbacks)
-{
-    LOGD("loc_eng_ni_init: entered.");
-
-    if (!loc_eng_ni_data_init)
-    {
-        pthread_mutex_init(&loc_eng_ni_data.loc_ni_lock, NULL);
-        callbacks->create_thread_cb("loc_api_ni", loc_ni_thread_proc, NULL);
-        loc_eng_ni_data_init = TRUE;
-    }
-
-    loc_eng_ni_data.notif_in_progress = FALSE;
-    loc_eng_ni_data.current_notif_id = -1;
-    loc_eng_ni_data.response_time_left = 0;
-
-    srand(time(NULL));
-    loc_eng_data.ni_notify_cb = callbacks->notify_cb;
-}
-
-/*===========================================================================
-FUNCTION    loc_eng_ni_respond
-
-DESCRIPTION
-   This function sends an NI respond to the modem processor
-
-DEPENDENCIES
-   NONE
-
-RETURN VALUE
-   None
-
-SIDE EFFECTS
-   N/A
-
-===========================================================================*/
-void loc_eng_ni_respond(int notif_id, GpsUserResponseType user_response)
-{
-    if (notif_id == loc_eng_ni_data.current_notif_id && loc_eng_ni_data.notif_in_progress)
-    {
-        LOGI("loc_eng_ni_respond: send user response %d for notif %d", user_response, notif_id);
-        loc_ni_process_user_response(user_response);
-    } else {
-        LOGE("loc_eng_ni_respond: notif_id %d mismatch or notification not in progress, response: %d",
-            notif_id, user_response);
-    }
-}
diff --git a/loc_api/libloc_api/loc_eng_ni.h b/loc_api/libloc_api/loc_eng_ni.h
deleted file mode 100644
index cfd2ab1..0000000
--- a/loc_api/libloc_api/loc_eng_ni.h
+++ /dev/null
@@ -1,56 +0,0 @@
-/* Copyright (c) 2009,2011 The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above
- *       copyright notice, this list of conditions and the following
- *       disclaimer in the documentation and/or other materials provided
- *       with the distribution.
- *     * Neither the name of The Linux Foundation nor the names of its
- *       contributors may be used to endorse or promote products derived
- *       from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef LOC_ENG_NI_H
-#define LOC_ENG_NI_H
-
-#include <hardware/gps.h>
-
-#define LOC_NI_NO_RESPONSE_TIME            20                      /* secs */
-
-extern const GpsNiInterface sLocEngNiInterface;
-
-typedef struct {
-    pthread_mutex_t         loc_ni_lock;
-    int                     response_time_left;       /* examine time for NI response */
-    boolean                 notif_in_progress;        /* NI notification/verification in progress */
-    rpc_loc_ni_event_s_type loc_ni_request;
-    int                     current_notif_id;         /* ID to check against response */
-} loc_eng_ni_data_s_type;
-
-// Functions for sLocEngNiInterface
-extern void loc_eng_ni_init(GpsNiCallbacks *callbacks);
-extern void loc_eng_ni_respond(int notif_id, GpsUserResponseType user_response);
-
-extern int loc_eng_ni_callback (
-        rpc_loc_event_mask_type               loc_event,              /* event mask           */
-        const rpc_loc_event_payload_u_type*   loc_event_payload       /* payload              */
-);
-
-#endif /* LOC_ENG_NI_H */
diff --git a/loc_api/libloc_api/loc_eng_xtra.cpp b/loc_api/libloc_api/loc_eng_xtra.cpp
deleted file mode 100644
index 0c3e476..0000000
--- a/loc_api/libloc_api/loc_eng_xtra.cpp
+++ /dev/null
@@ -1,180 +0,0 @@
-/* Copyright (c) 2009,2011 The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above
- *       copyright notice, this list of conditions and the following
- *       disclaimer in the documentation and/or other materials provided
- *       with the distribution.
- *     * Neither the name of The Linux Foundation nor the names of its
- *       contributors may be used to endorse or promote products derived
- *       from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#define LOG_NDDEBUG 0
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <ctype.h>
-#include <errno.h>
-#include <math.h>
-#include <pthread.h>
-
-#include <rpc/rpc.h>
-#include <loc_api_rpc_glue.h>
-
-#include <loc_eng.h>
-
-#define LOG_TAG "lib_locapi"
-#include <utils/Log.h>
-
-// comment this out to enable logging
-// #undef LOGD
-// #define LOGD(...) {}
-
-#define LOC_XTRA_INJECT_DEFAULT_TIMEOUT (3100)
-#define XTRA_BLOCK_SIZE                 (400)
-
-static int qct_loc_eng_xtra_init (GpsXtraCallbacks* callbacks);
-static int qct_loc_eng_inject_xtra_data(char* data, int length);
-
-const GpsXtraInterface sLocEngXTRAInterface =
-{
-    sizeof(GpsXtraInterface),
-    qct_loc_eng_xtra_init,
-    qct_loc_eng_inject_xtra_data,
-};
-
-/*===========================================================================
-FUNCTION    qct_loc_eng_xtra_init
-
-DESCRIPTION
-   Initialize XTRA module.
-
-DEPENDENCIES
-   N/A
-
-RETURN VALUE
-   0: success
-
-SIDE EFFECTS
-   N/A
-
-===========================================================================*/
-static int qct_loc_eng_xtra_init (GpsXtraCallbacks* callbacks)
-{
-    rpc_loc_event_mask_type event;
-    loc_eng_xtra_data_s_type *xtra_module_data_ptr;
-
-    xtra_module_data_ptr = &(loc_eng_data.xtra_module_data);
-    xtra_module_data_ptr->download_request_cb = callbacks->download_request_cb;
-
-    return 0;
-}
-
-/*===========================================================================
-FUNCTION    qct_loc_eng_inject_xtra_data
-
-DESCRIPTION
-   Injects XTRA file into the engine. 
-
-DEPENDENCIES
-   N/A
-
-RETURN VALUE
-   0: success
-   >0: failure
-
-SIDE EFFECTS
-   N/A
-
-===========================================================================*/
-static int qct_loc_eng_inject_xtra_data(char* data, int length)
-{
-    int     rpc_ret_val = RPC_LOC_API_GENERAL_FAILURE;
-    boolean ret_val = 0;
-    int     total_parts;
-    uint8   part;
-    uint16  part_len;
-    uint16  len_injected;
-    rpc_loc_ioctl_data_u_type            ioctl_data;
-    rpc_loc_predicted_orbits_data_s_type *predicted_orbits_data_ptr;
-
-    LOGV ("qct_loc_eng_inject_xtra_data, xtra size = %d, data ptr = 0x%x\n", length, (int) data);
-
-    ioctl_data.disc = RPC_LOC_IOCTL_INJECT_PREDICTED_ORBITS_DATA;
-
-    predicted_orbits_data_ptr = &(ioctl_data.rpc_loc_ioctl_data_u_type_u.predicted_orbits_data);
-    predicted_orbits_data_ptr->format_type = RPC_LOC_PREDICTED_ORBITS_XTRA;
-    predicted_orbits_data_ptr->total_size = length;
-    total_parts = (length / XTRA_BLOCK_SIZE);
-    if ((total_parts % XTRA_BLOCK_SIZE) != 0)
-    {
-        total_parts += 1;
-    }
-    predicted_orbits_data_ptr->total_parts = total_parts;
-
-    len_injected = 0; // O bytes injected
-    // XTRA injection starts with part 1
-    for (part = 1; part <= total_parts; part++)
-    {
-        predicted_orbits_data_ptr->part = part;
-        predicted_orbits_data_ptr->part_len = XTRA_BLOCK_SIZE;
-        if (XTRA_BLOCK_SIZE > (length - len_injected))
-        {
-            predicted_orbits_data_ptr->part_len = length - len_injected;
-        }
-        predicted_orbits_data_ptr->data_ptr.data_ptr_len = predicted_orbits_data_ptr->part_len;
-        predicted_orbits_data_ptr->data_ptr.data_ptr_val = data + len_injected;
-
-        LOGV ("qct_loc_eng_inject_xtra_data, inject part = %d, len = %d, len = %d\n", predicted_orbits_data_ptr->part, predicted_orbits_data_ptr->part_len, predicted_orbits_data_ptr->data_ptr.data_ptr_len);
-        LOGV ("qct_loc_eng_inject_xtra_data, total part = %d, len = %d \n", predicted_orbits_data_ptr->part, predicted_orbits_data_ptr->part_len);
-
-        if (part < total_parts)
-        {
-            // No callback in this case
-            rpc_ret_val = loc_ioctl (loc_eng_data.client_handle,
-                                  RPC_LOC_IOCTL_INJECT_PREDICTED_ORBITS_DATA,
-                                  &ioctl_data);
-
-            if (rpc_ret_val != RPC_LOC_API_SUCCESS)
-            {
-                LOGE ("loc_ioctl for xtra returned %d \n", rpc_ret_val);
-                ret_val = EINVAL; // return error
-                break;
-            }
-        }
-        else // part == total_parts
-        {
-            // Last part injection, will need to wait for callback
-            ret_val = loc_eng_ioctl (loc_eng_data.client_handle,
-                                  RPC_LOC_IOCTL_INJECT_PREDICTED_ORBITS_DATA,
-                                  &ioctl_data,
-                                  LOC_XTRA_INJECT_DEFAULT_TIMEOUT,
-                                  NULL /* No output information is expected*/);
-            break; // done with injection
-        }
-
-        len_injected += predicted_orbits_data_ptr->part_len;
-        LOGV ("loc_ioctl for xtra len injected %d \n", len_injected);
-    }
-
-    return ret_val;
-}
diff --git a/loc_api/libloc_api_50001/Android.mk b/loc_api/libloc_api_50001/Android.mk
index a1488a0..8f5d389 100644
--- a/loc_api/libloc_api_50001/Android.mk
+++ b/loc_api/libloc_api_50001/Android.mk
@@ -74,7 +74,8 @@ LOCAL_SHARED_LIBRARIES := \
     libloc_eng \
     libloc_core \
     libgps.utils \
-    libdl
+    libdl \
+    libmdmdetect
 
 LOCAL_SRC_FILES += \
     loc.cpp \
@@ -91,7 +92,8 @@ endif
 ## Includes
 LOCAL_C_INCLUDES:= \
     $(TARGET_OUT_HEADERS)/gps.utils \
-    $(TARGET_OUT_HEADERS)/libloc_core
+    $(TARGET_OUT_HEADERS)/libloc_core \
+    $(TARGET_OUT_HEADERS)/libmdmdetect/inc
 
 LOCAL_PRELINK_MODULE := false
 LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/hw
diff --git a/loc_api/libloc_api_50001/LocEngAdapter.cpp b/loc_api/libloc_api_50001/LocEngAdapter.cpp
index 116a8ae..1e6e4e1 100644
--- a/loc_api/libloc_api_50001/LocEngAdapter.cpp
+++ b/loc_api/libloc_api_50001/LocEngAdapter.cpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2011-2013, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2011-2014, 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
@@ -49,35 +49,31 @@ void LocInternalAdapter::startFixInt() {
 void LocInternalAdapter::stopFixInt() {
     sendMsg(new LocEngStopFix(mLocEngAdapter));
 }
-void LocInternalAdapter::setUlpProxy(UlpProxyBase* ulp) {
-    struct LocSetUlpProxy : public LocMsg {
-        LocAdapterBase* mAdapter;
-        UlpProxyBase* mUlp;
-        inline LocSetUlpProxy(LocAdapterBase* adapter, UlpProxyBase* ulp) :
-            LocMsg(), mAdapter(adapter), mUlp(ulp) {
-        }
-        virtual void proc() const {
-            LOC_LOGV("%s] ulp %p adapter %p", __func__,
-                     mUlp, mAdapter);
-            mAdapter->setUlpProxy(mUlp);
-        }
-    };
+void LocInternalAdapter::getZppInt() {
+    sendMsg(new LocEngGetZpp(mLocEngAdapter));
+}
 
-    sendMsg(new LocSetUlpProxy(mLocEngAdapter, ulp));
+void LocInternalAdapter::shutdown() {
+    sendMsg(new LocEngShutdown(mLocEngAdapter));
 }
 
 LocEngAdapter::LocEngAdapter(LOC_API_ADAPTER_EVENT_MASK_T mask,
-                             void* owner,
+                             void* owner, ContextBase* context,
                              MsgTask::tCreate tCreator) :
     LocAdapterBase(mask,
-                   LocDualContext::getLocFgContext(
-                         tCreator,
-                         LocDualContext::mLocationHalName)),
+                   //Get the AFW context if VzW context has not already been intialized in
+                   //loc_ext
+                   context == NULL?
+                   LocDualContext::getLocFgContext(tCreator,
+                                                   LocDualContext::mLocationHalName)
+                   :context),
     mOwner(owner), mInternalAdapter(new LocInternalAdapter(this)),
     mUlp(new UlpProxyBase()), mNavigating(false),
-    mAgpsEnabled(false)
+    mSupportsAgpsRequests(false),
+    mSupportsPositionInjection(false), mPowerVote(0)
 {
     memset(&mFixCriteria, 0, sizeof(mFixCriteria));
+    mFixCriteria.mode = LOC_POSITION_MODE_INVALID;
     LOC_LOGD("LocEngAdapter created");
 }
 
@@ -88,16 +84,84 @@ LocEngAdapter::~LocEngAdapter()
     LOC_LOGV("LocEngAdapter deleted");
 }
 
+void LocInternalAdapter::setUlpProxy(UlpProxyBase* ulp) {
+    struct LocSetUlpProxy : public LocMsg {
+        LocAdapterBase* mAdapter;
+        UlpProxyBase* mUlp;
+        inline LocSetUlpProxy(LocAdapterBase* adapter, UlpProxyBase* ulp) :
+            LocMsg(), mAdapter(adapter), mUlp(ulp) {
+        }
+        virtual void proc() const {
+            LOC_LOGV("%s] ulp %p adapter %p", __func__,
+                     mUlp, mAdapter);
+            mAdapter->setUlpProxy(mUlp);
+        }
+    };
+
+    sendMsg(new LocSetUlpProxy(mLocEngAdapter, ulp));
+}
+
 void LocEngAdapter::setUlpProxy(UlpProxyBase* ulp)
 {
-    delete mUlp;
+    if (ulp == mUlp) {
+        //This takes care of the case when double initalization happens
+        //and we get the same object back for UlpProxyBase . Do nothing
+        return;
+    }
+
     LOC_LOGV("%s] %p", __func__, ulp);
     if (NULL == ulp) {
+        LOC_LOGE("%s:%d]: ulp pointer is NULL", __func__, __LINE__);
         ulp = new UlpProxyBase();
     }
+
+    if (LOC_POSITION_MODE_INVALID != mUlp->mPosMode.mode) {
+        // need to send this mode and start msg to ULP
+        ulp->sendFixMode(mUlp->mPosMode);
+    }
+
+    if(mUlp->mFixSet) {
+        ulp->sendStartFix();
+    }
+
+    delete mUlp;
     mUlp = ulp;
 }
 
+void LocEngAdapter::requestPowerVote()
+{
+    struct LocEngAdapterVotePower : public LocMsg {
+        LocEngAdapter* mAdapter;
+        const bool mPowerUp;
+        inline LocEngAdapterVotePower(LocEngAdapter* adapter, bool powerUp) :
+            LocMsg(), mAdapter(adapter), mPowerUp(powerUp)
+        {
+            locallog();
+        }
+        inline virtual void proc() const {
+            /* Power voting without engine lock:
+             * 101: vote down, 102-104 - vote up
+             * These codes are used not to confuse with actual engine lock
+             * functionality, that can't be used in SSR scenario, as it
+             * conflicts with initialization sequence.
+             */
+            int mode = mPowerUp ? 103 : 101;
+            mAdapter->setGpsLock(mode);
+        }
+        inline  void locallog() const {
+            LOC_LOGV("LocEngAdapterVotePower - Vote Power: %d",
+                     (int)mPowerUp);
+        }
+        inline virtual void log() const {
+            locallog();
+        }
+    };
+
+    if (getPowerVoteRight()) {
+        sendMsg(new LocEngAdapterVotePower(this, getPowerVote()));
+    }
+}
+
 void LocInternalAdapter::reportPosition(UlpLocation &location,
                                         GpsLocationExtended &locationExtended,
                                         void* locationExt,
@@ -152,10 +216,25 @@ void LocEngAdapter::reportSv(GpsSvStatus &svStatus,
     }
 }
 
-inline
+void LocEngAdapter::setInSession(bool inSession)
+{
+    mNavigating = inSession;
+    mLocApi->setInSession(inSession);
+    if (!mNavigating) {
+        mFixCriteria.mode = LOC_POSITION_MODE_INVALID;
+    }
+}
+
+void LocInternalAdapter::reportStatus(GpsStatusValue status)
+{
+    sendMsg(new LocEngReportStatus(mLocEngAdapter, status));
+}
+
 void LocEngAdapter::reportStatus(GpsStatusValue status)
 {
-    sendMsg(new LocEngReportStatus(mOwner, status));
+    if (!mUlp->reportStatus(status)) {
+        mInternalAdapter->reportStatus(status);
+    }
 }
 
 inline
@@ -170,81 +249,84 @@ bool LocEngAdapter::reportXtraServer(const char* url1,
                                         const char* url3,
                                         const int maxlength)
 {
-    if (mAgpsEnabled) {
+    if (mSupportsAgpsRequests) {
         sendMsg(new LocEngReportXtraServer(mOwner, url1,
                                            url2, url3, maxlength));
     }
-    return mAgpsEnabled;
+    return mSupportsAgpsRequests;
 }
 
 inline
 bool LocEngAdapter::requestATL(int connHandle, AGpsType agps_type)
 {
-    if (mAgpsEnabled) {
+    if (mSupportsAgpsRequests) {
         sendMsg(new LocEngRequestATL(mOwner,
                                      connHandle, agps_type));
     }
-    return mAgpsEnabled;
+    return mSupportsAgpsRequests;
 }
 
 inline
 bool LocEngAdapter::releaseATL(int connHandle)
 {
-    if (mAgpsEnabled) {
+    if (mSupportsAgpsRequests) {
         sendMsg(new LocEngReleaseATL(mOwner, connHandle));
     }
-    return mAgpsEnabled;
+    return mSupportsAgpsRequests;
 }
 
 inline
 bool LocEngAdapter::requestXtraData()
 {
-    if (mAgpsEnabled) {
+    if (mSupportsAgpsRequests) {
         sendMsg(new LocEngRequestXtra(mOwner));
     }
-    return mAgpsEnabled;
+    return mSupportsAgpsRequests;
 }
 
 inline
 bool LocEngAdapter::requestTime()
 {
-    if (mAgpsEnabled) {
+    if (mSupportsAgpsRequests) {
         sendMsg(new LocEngRequestTime(mOwner));
     }
-    return mAgpsEnabled;
+    return mSupportsAgpsRequests;
 }
 
 inline
 bool LocEngAdapter::requestNiNotify(GpsNiNotification &notif, const void* data)
 {
-    if (mAgpsEnabled) {
+    if (mSupportsAgpsRequests) {
         notif.size = sizeof(notif);
         notif.timeout = LOC_NI_NO_RESPONSE_TIME;
 
         sendMsg(new LocEngRequestNi(mOwner, notif, data));
     }
-    return mAgpsEnabled;
+    return mSupportsAgpsRequests;
 }
 
 inline
 bool LocEngAdapter::requestSuplES(int connHandle)
 {
-    sendMsg(new LocEngRequestSuplEs(mOwner, connHandle));
-    return true;
+    if (mSupportsAgpsRequests)
+        sendMsg(new LocEngRequestSuplEs(mOwner, connHandle));
+    return mSupportsAgpsRequests;
 }
 
 inline
 bool LocEngAdapter::reportDataCallOpened()
 {
-    sendMsg(new LocEngSuplEsOpened(mOwner));
-    return true;
+    if(mSupportsAgpsRequests)
+        sendMsg(new LocEngSuplEsOpened(mOwner));
+    return mSupportsAgpsRequests;
 }
 
 inline
 bool LocEngAdapter::reportDataCallClosed()
 {
-    sendMsg(new LocEngSuplEsClosed(mOwner));
-    return true;
+    if(mSupportsAgpsRequests)
+        sendMsg(new LocEngSuplEsClosed(mOwner));
+    return mSupportsAgpsRequests;
 }
 
 inline
diff --git a/loc_api/libloc_api_50001/LocEngAdapter.h b/loc_api/libloc_api_50001/LocEngAdapter.h
index 6ad3ba9..93f3dc2 100644
--- a/loc_api/libloc_api_50001/LocEngAdapter.h
+++ b/loc_api/libloc_api_50001/LocEngAdapter.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2011-2013, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2011-2014, 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
@@ -58,10 +58,13 @@ public:
     virtual void reportSv(GpsSvStatus &svStatus,
                           GpsLocationExtended &locationExtended,
                           void* svExt);
+    virtual void reportStatus(GpsStatusValue status);
     virtual void setPositionModeInt(LocPosMode& posMode);
     virtual void startFixInt();
     virtual void stopFixInt();
+    virtual void getZppInt();
     virtual void setUlpProxy(UlpProxyBase* ulp);
+    virtual void shutdown();
 };
 
 typedef void (*loc_msg_sender)(void* loc_eng_data_p, void* msgp);
@@ -72,12 +75,19 @@ class LocEngAdapter : public LocAdapterBase {
     UlpProxyBase* mUlp;
     LocPosMode mFixCriteria;
     bool mNavigating;
+    // mPowerVote is encoded as
+    // mPowerVote & 0x20 -- powerVoteRight
+    // mPowerVote & 0x10 -- power On / Off
+    unsigned int mPowerVote;
+    static const unsigned int POWER_VOTE_RIGHT = 0x20;
+    static const unsigned int POWER_VOTE_VALUE = 0x10;
 
 public:
-    bool mAgpsEnabled;
+    bool mSupportsAgpsRequests;
+    bool mSupportsPositionInjection;
 
     LocEngAdapter(LOC_API_ADAPTER_EVENT_MASK_T mask,
-                  void* owner,
+                  void* owner, ContextBase* context,
                   MsgTask::tCreate tCreator);
     virtual ~LocEngAdapter();
 
@@ -88,7 +98,12 @@ public:
     inline LocInternalAdapter* getInternalAdapter() { return mInternalAdapter; }
     inline UlpProxyBase* getUlpProxy() { return mUlp; }
     inline void* getOwner() { return mOwner; }
-    inline bool hasAgpsExt() { return mContext->hasAgpsExt(); }
+    inline bool hasAgpsExtendedCapabilities() {
+        return mContext->hasAgpsExtendedCapabilities();
+    }
+    inline bool hasCPIExtendedCapabilities() {
+        return mContext->hasCPIExtendedCapabilities();
+    }
     inline const MsgTask* getMsgTask() { return mMsgTask; }
 
     inline enum loc_api_adapter_err
@@ -181,9 +196,9 @@ public:
         return mLocApi->setLPPConfig(profile);
     }
     inline enum loc_api_adapter_err
-        setSensorControlConfig(int sensorUsage)
+        setSensorControlConfig(int sensorUsage, int sensorProvider)
     {
-        return mLocApi->setSensorControlConfig(sensorUsage);
+        return mLocApi->setSensorControlConfig(sensorUsage, sensorProvider);
     }
     inline enum loc_api_adapter_err
         setSensorProperties(bool gyroBiasVarianceRandomWalk_valid, float gyroBiasVarianceRandomWalk,
@@ -236,6 +251,11 @@ public:
     {
         mLocApi->closeDataCall();
     }
+    inline enum loc_api_adapter_err
+        getZpp(GpsLocation &zppLoc, LocPosTechMask &tech_mask)
+    {
+        return mLocApi->getBestAvailableZppFix(zppLoc, tech_mask);
+    }
 
     virtual void handleEngineDownEvent();
     virtual void handleEngineUpEvent();
@@ -264,8 +284,47 @@ public:
     {return mFixCriteria;}
     inline virtual bool isInSession()
     { return mNavigating; }
-    inline void setInSession(bool inSession)
-    { mNavigating = inSession; mLocApi->setInSession(inSession); }
+    void setInSession(bool inSession);
+
+    // Permit/prohibit power voting
+    inline void setPowerVoteRight(bool powerVoteRight) {
+        mPowerVote = powerVoteRight ? (mPowerVote | POWER_VOTE_RIGHT) :
+                                      (mPowerVote & ~POWER_VOTE_RIGHT);
+    }
+    inline bool getPowerVoteRight() const {
+        return (mPowerVote & POWER_VOTE_RIGHT) != 0 ;
+    }
+    // Set the power voting up/down and do actual operation if permitted
+    inline void setPowerVote(bool powerOn) {
+        mPowerVote = powerOn ? (mPowerVote | POWER_VOTE_VALUE) :
+                               (mPowerVote & ~POWER_VOTE_VALUE);
+        requestPowerVote();
+    }
+    inline bool getPowerVote() const {
+        return (mPowerVote & POWER_VOTE_VALUE) != 0 ;
+    }
+    // Do power voting according to last settings if permitted
+    void requestPowerVote();
+
+    /*Values for lock
+      1 = Do not lock any position sessions
+      2 = Lock MI position sessions
+      3 = Lock MT position sessions
+      4 = Lock all position sessions
+    */
+    inline int setGpsLock(unsigned int lock)
+    {
+        return mLocApi->setGpsLock(lock);
+    }
+    /*
+      Returns
+      Current value of GPS lock on success
+      -1 on failure
+     */
+    inline int getGpsLock()
+    {
+        return mLocApi->getGpsLock();
+    }
 };
 
 #endif //LOC_API_ENG_ADAPTER_H
diff --git a/loc_api/libloc_api_50001/gps.c b/loc_api/libloc_api_50001/gps.c
index 82bc742..b0669af 100644
--- a/loc_api/libloc_api_50001/gps.c
+++ b/loc_api/libloc_api_50001/gps.c
@@ -42,6 +42,10 @@ static int open_gps(const struct hw_module_t* module, char const* name,
         struct hw_device_t** device)
 {
     struct gps_device_t *dev = (struct gps_device_t *) malloc(sizeof(struct gps_device_t));
+
+    if(dev == NULL)
+        return -1;
+
     memset(dev, 0, sizeof(*dev));
 
     dev->common.tag = HARDWARE_DEVICE_TAG;
diff --git a/loc_api/libloc_api_50001/loc.cpp b/loc_api/libloc_api_50001/loc.cpp
index f765966..ac65d25 100644
--- a/loc_api/libloc_api_50001/loc.cpp
+++ b/loc_api/libloc_api_50001/loc.cpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2011-2013, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2011-2014, 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,7 +44,13 @@
 #include <errno.h>
 #include <LocDualContext.h>
 #include <cutils/properties.h>
-
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+#include <mdm_detect.h>
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
 using namespace loc_core;
 
 //Globals defns
@@ -68,7 +74,7 @@ static int  loc_set_position_mode(GpsPositionMode mode, GpsPositionRecurrence re
                                   uint32_t min_interval, uint32_t preferred_accuracy,
                                   uint32_t preferred_time);
 static const void* loc_get_extension(const char* name);
-
+static void loc_close_mdm_node();
 // Defines the GpsInterface in gps.h
 static const GpsInterface sLocEngInterface =
 {
@@ -121,6 +127,9 @@ const GpsNiInterface sLocEngNiInterface =
    loc_ni_respond,
 };
 
+// For shutting down MDM in fusion devices
+static int mdm_fd = -1;
+
 static void loc_agps_ril_init( AGpsRilCallbacks* callbacks );
 static void loc_agps_ril_set_ref_location(const AGpsRefLocation *agps_reflocation, size_t sz_struct);
 static void loc_agps_ril_set_set_id(AGpsSetIDType type, const char* setid);
@@ -140,7 +149,7 @@ static const AGpsRilInterface sLocEngAGpsRilInterface =
 };
 
 static loc_eng_data_s_type loc_afw_data;
-static int gss_fd = 0;
+static int gss_fd = -1;
 
 /*===========================================================================
 FUNCTION    gps_get_hardware_interface
@@ -190,10 +199,14 @@ extern "C" const GpsInterface* get_gps_interface()
     unsigned int target = TARGET_DEFAULT;
     loc_eng_read_config();
 
-    target = get_target();
+    target = loc_get_target();
     LOC_LOGD("Target name check returned %s", loc_get_target_name(target));
+
+    int gnssType = getTargetGnssType(target);
+    switch (gnssType)
+    {
+    case GNSS_GSS:
         //APQ8064
-        if( getTargetGnssType(target) == GNSS_GSS ) {
         gps_conf.CAPABILITIES &= ~(GPS_CAPABILITY_MSA | GPS_CAPABILITY_MSB);
         gss_fd = open("/dev/gss", O_RDONLY);
         if (gss_fd < 0) {
@@ -203,11 +216,16 @@ extern "C" const GpsInterface* get_gps_interface()
             LOC_LOGD("GSS open success! CAPABILITIES %0lx\n",
                      gps_conf.CAPABILITIES);
         }
-    }
-    //MPQ8064
-        else if( getTargetGnssType(target) == GNSS_NONE) {
-        LOC_LOGE("No GPS HW on this target (MPQ8064). Not returning interface");
+        break;
+    case GNSS_NONE:
+        //MPQ8064
+        LOC_LOGE("No GPS HW on this target. Not returning interface.");
         return NULL;
+    case GNSS_QCA1530:
+        // qca1530 chip is present
+        gps_conf.CAPABILITIES &= ~(GPS_CAPABILITY_MSA | GPS_CAPABILITY_MSB);
+        LOC_LOGD("qca1530 present: CAPABILITIES %0lx\n", gps_conf.CAPABILITIES);
+        break;
     }
     return &sLocEngInterface;
 }
@@ -232,6 +250,7 @@ SIDE EFFECTS
 static int loc_init(GpsCallbacks* callbacks)
 {
     int retVal = -1;
+    int i = 0;
     ENTRY_LOG();
     LOC_API_ADAPTER_EVENT_MASK_T event;
 
@@ -260,21 +279,93 @@ static int loc_init(GpsCallbacks* callbacks)
                                     callbacks->create_thread_cb, /* create_thread_cb */
                                     NULL, /* location_ext_parser */
                                     NULL, /* sv_ext_parser */
-                                    callbacks->request_utc_time_cb /* request_utc_time_cb */};
+                                    callbacks->request_utc_time_cb, /* request_utc_time_cb */
+                                    loc_close_mdm_node  /*loc_shutdown_cb*/};
 
     gps_loc_cb = callbacks->location_cb;
     gps_sv_cb = callbacks->sv_status_cb;
 
-    retVal = loc_eng_init(loc_afw_data, &clientCallbacks, event);
+    retVal = loc_eng_init(loc_afw_data, &clientCallbacks, event, NULL);
     loc_afw_data.adapter->requestUlp(gps_conf.CAPABILITIES);
-    loc_afw_data.adapter->mAgpsEnabled = !loc_afw_data.adapter->hasAgpsExt();
+    loc_afw_data.adapter->mSupportsAgpsRequests = !loc_afw_data.adapter->hasAgpsExtendedCapabilities();
+    loc_afw_data.adapter->mSupportsPositionInjection = !loc_afw_data.adapter->hasCPIExtendedCapabilities();
+
+    if(retVal) {
+        LOC_LOGE("loc_eng_init() fail!");
+        goto err;
+    }
 
+    loc_afw_data.adapter->setPowerVoteRight(loc_get_target() == TARGET_QCA1530);
+    loc_afw_data.adapter->setPowerVote(true);
+
+    LOC_LOGD("loc_eng_init() success!");
+    if (mdm_fd < 0) {
+        struct dev_info modem_info;
+        memset(&modem_info, 0, sizeof(struct dev_info));
+        if(get_system_info(&modem_info) != RET_SUCCESS) {
+            LOC_LOGE("%s:%d]: Error: get_system_info returned error\n",
+                     __func__, __LINE__);
+            goto err;
+        }
+        for(i=0; i<modem_info.num_modems; i++) {
+            if((modem_info.mdm_list[i].type == MDM_TYPE_EXTERNAL) &&
+               (modem_info.mdm_list[i].powerup_node)) {
+                LOC_LOGD("%s:%d]: powerup_node: %s", __func__, __LINE__,
+                         modem_info.mdm_list[i].powerup_node);
+                mdm_fd = open(modem_info.mdm_list[i].powerup_node, O_RDONLY);
+                if (mdm_fd < 0) {
+                    LOC_LOGE("Error: %s open failed: %s\n",
+                             modem_info.mdm_list[i].powerup_node, strerror(errno));
+                } else {
+                    LOC_LOGD("%s opens success!", modem_info.mdm_list[i].powerup_node);
+                }
+            }
+            else {
+                LOC_LOGD("%s:%d]: powerup_node not present in mdm %d",
+                         __func__, __LINE__, i);
+            }
+        }
+    } else {
+        LOC_LOGD("powerup_node has been opened before");
+    }
 
+err:
     EXIT_LOG(%d, retVal);
     return retVal;
 }
 
 /*===========================================================================
+FUNCTION    loc_close_mdm_node
+
+DESCRIPTION
+   closes mdm_fd which is the modem powerup node obtained in loc_init
+
+DEPENDENCIES
+   None
+
+RETURN VALUE
+   None
+
+SIDE EFFECTS
+   N/A
+
+===========================================================================*/
+static void loc_close_mdm_node()
+{
+    ENTRY_LOG();
+    if (mdm_fd >= 0) {
+        LOC_LOGD("closing the powerup node");
+        close(mdm_fd);
+        mdm_fd = -1;
+        LOC_LOGD("finished closing the powerup node");
+    } else {
+        LOC_LOGD("powerup node has not been opened yet.");
+    }
+
+    EXIT_LOG(%s, VOID_RET);
+}
+
+/*===========================================================================
 FUNCTION    loc_cleanup
 
 DESCRIPTION
@@ -293,18 +384,14 @@ SIDE EFFECTS
 static void loc_cleanup()
 {
     ENTRY_LOG();
+
+    loc_afw_data.adapter->setPowerVote(false);
+
     loc_eng_cleanup(loc_afw_data);
+    loc_close_mdm_node();
     gps_loc_cb = NULL;
     gps_sv_cb = NULL;
 
-    /*
-     * if (get_target() == TARGET_NAME_APQ8064_STANDALONE)
-     * {
-     *     close(gss_fd);
-     *     LOC_LOGD("GSS shutdown.\n");
-     * }
-     */
-
     EXIT_LOG(%s, VOID_RET);
 }
 
@@ -455,6 +542,14 @@ static int loc_inject_location(double latitude, double longitude, float accuracy
     static bool enable_cpi = true;
     ENTRY_LOG();
 
+    if (accuracy < 1000)
+    {
+      accuracy = 1000;
+    }
+
+    int ret_val = 0;
+    ret_val = loc_eng_inject_location(loc_afw_data, latitude, longitude, accuracy);
+
     if(!initialized)
     {
         char value[PROPERTY_VALUE_MAX];
@@ -571,19 +666,7 @@ const void* loc_get_extension(const char* name)
    }
    else if (strcmp(name, AGPS_INTERFACE) == 0)
    {
-       //Return an interface to AGPS only if MSA or MSB capabilities
-       //are present. If the target is an APQ, these masks are
-       //cleared in get_gps_interface() and the below logic will
-       //return NULL as the interface for AGPS
-       if((gps_conf.CAPABILITIES & GPS_CAPABILITY_MSA) ||
-          (gps_conf.CAPABILITIES & GPS_CAPABILITY_MSB) ) {
-           LOC_LOGD("%s:%d]: AGPS capabilities found\n", __func__, __LINE__);
-           ret_val = &sLocEngAGpsInterface;
-       }
-       else {
-           LOC_LOGD("%s:%d]: Returning NULL AgpsInterface\n", __func__, __LINE__);
-           ret_val = NULL;
-       }
+       ret_val = &sLocEngAGpsInterface;
    }
    else if (strcmp(name, GPS_NI_INTERFACE) == 0)
    {
diff --git a/loc_api/libloc_api_50001/loc.h b/loc_api/libloc_api_50001/loc.h
index c959323..7e26827 100644
--- a/loc_api/libloc_api_50001/loc.h
+++ b/loc_api/libloc_api_50001/loc.h
@@ -42,6 +42,7 @@ extern "C" {
 typedef void (*loc_location_cb_ext) (UlpLocation* location, void* locExt);
 typedef void (*loc_sv_status_cb_ext) (GpsSvStatus* sv_status, void* svExt);
 typedef void* (*loc_ext_parser)(void* data);
+typedef void (*loc_shutdown_cb) (void);
 
 typedef struct {
     loc_location_cb_ext location_cb;
@@ -55,6 +56,7 @@ typedef struct {
     loc_ext_parser location_ext_parser;
     loc_ext_parser sv_ext_parser;
     gps_request_utc_time request_utc_time_cb;
+    loc_shutdown_cb shutdown_cb;
 } LocCallbacks;
 
 #ifdef __cplusplus
diff --git a/loc_api/libloc_api_50001/loc_eng.cpp b/loc_api/libloc_api_50001/loc_eng.cpp
index 357cf63..c336dd1 100644
--- a/loc_api/libloc_api_50001/loc_eng.cpp
+++ b/loc_api/libloc_api_50001/loc_eng.cpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2009-2013, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2009-2014, 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
@@ -96,7 +96,6 @@ static loc_param_s_type loc_parameter_table[] =
 {
   {"INTERMEDIATE_POS",               &gps_conf.INTERMEDIATE_POS,               NULL, 'n'},
   {"ACCURACY_THRES",                 &gps_conf.ACCURACY_THRES,                 NULL, 'n'},
-  {"ENABLE_WIPER",                   &gps_conf.ENABLE_WIPER,                   NULL, 'n'},
   {"NMEA_PROVIDER",                  &gps_conf.NMEA_PROVIDER,                  NULL, 'n'},
   {"SUPL_VER",                       &gps_conf.SUPL_VER,                       NULL, 'n'},
   {"CAPABILITIES",                   &gps_conf.CAPABILITIES,                   NULL, 'n'},
@@ -116,9 +115,9 @@ static loc_param_s_type loc_parameter_table[] =
   {"SENSOR_CONTROL_MODE",            &sap_conf.SENSOR_CONTROL_MODE,            NULL, 'n'},
   {"SENSOR_USAGE",                   &sap_conf.SENSOR_USAGE,                   NULL, 'n'},
   {"SENSOR_ALGORITHM_CONFIG_MASK",   &sap_conf.SENSOR_ALGORITHM_CONFIG_MASK,   NULL, 'n'},
-  {"QUIPC_ENABLED",                  &gps_conf.QUIPC_ENABLED,                  NULL, 'n'},
   {"LPP_PROFILE",                    &gps_conf.LPP_PROFILE,                    NULL, 'n'},
   {"A_GLONASS_POS_PROTOCOL_SELECT",  &gps_conf.A_GLONASS_POS_PROTOCOL_SELECT,  NULL, 'n'},
+  {"SENSOR_PROVIDER",                &sap_conf.SENSOR_PROVIDER,                NULL, 'n'},
 };
 
 static void loc_default_parameters(void)
@@ -126,7 +125,6 @@ static void loc_default_parameters(void)
    /* defaults */
    gps_conf.INTERMEDIATE_POS = 0;
    gps_conf.ACCURACY_THRES = 0;
-   gps_conf.ENABLE_WIPER = 0;
    gps_conf.NMEA_PROVIDER = 0;
    gps_conf.SUPL_VER = 0x10000;
    gps_conf.CAPABILITIES = 0x7;
@@ -162,6 +160,9 @@ static void loc_default_parameters(void)
 
    /*By default no positioning protocol is selected on A-GLONASS system*/
    gps_conf.A_GLONASS_POS_PROTOCOL_SELECT = 0;
+
+   /* default provider is SSC */
+   sap_conf.SENSOR_PROVIDER = 1;
 }
 
 // 2nd half of init(), singled out for
@@ -184,11 +185,12 @@ static void loc_eng_handle_engine_up(loc_eng_data_s_type &loc_eng_data) ;
 
 static int loc_eng_start_handler(loc_eng_data_s_type &loc_eng_data);
 static int loc_eng_stop_handler(loc_eng_data_s_type &loc_eng_data);
-
+static int loc_eng_get_zpp_handler(loc_eng_data_s_type &loc_eng_data);
+static void loc_eng_handle_shutdown(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 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 &&
         loc_eng_data.aiding_data_for_deletion != 0)
@@ -302,6 +304,49 @@ void LocEngPositionMode::send() const {
     mAdapter->sendMsg(this);
 }
 
+LocEngGetZpp::LocEngGetZpp(LocEngAdapter* adapter) :
+    LocMsg(), mAdapter(adapter)
+{
+    locallog();
+}
+inline void LocEngGetZpp::proc() const
+{
+    loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mAdapter->getOwner();
+    loc_eng_get_zpp_handler(*locEng);
+}
+inline void LocEngGetZpp::locallog() const
+{
+    LOC_LOGV("LocEngGetZpp");
+}
+inline void LocEngGetZpp::log() const
+{
+    locallog();
+}
+void LocEngGetZpp::send() const {
+    mAdapter->sendMsg(this);
+}
+
+
+LocEngShutdown::LocEngShutdown(LocEngAdapter* adapter) :
+    LocMsg(), mAdapter(adapter)
+{
+    locallog();
+}
+inline void LocEngShutdown::proc() const
+{
+    loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mAdapter->getOwner();
+    LOC_LOGD("%s:%d]: Calling loc_eng_handle_shutdown", __func__, __LINE__);
+    loc_eng_handle_shutdown(*locEng);
+}
+inline void LocEngShutdown::locallog() const
+{
+    LOC_LOGV("LocEngShutdown");
+}
+inline void LocEngShutdown::log() const
+{
+    locallog();
+}
+
 //        case LOC_ENG_MSG_SET_TIME:
 struct LocEngSetTime : public LocMsg {
     LocEngAdapter* mAdapter;
@@ -476,18 +521,20 @@ struct LocEngLppConfig : public LocMsg {
 struct LocEngSensorControlConfig : public LocMsg {
     LocEngAdapter* mAdapter;
     const int mSensorsDisabled;
+    const int mSensorProvider;
     inline LocEngSensorControlConfig(LocEngAdapter* adapter,
-                                     int sensorsDisabled) :
-        LocMsg(), mAdapter(adapter), mSensorsDisabled(sensorsDisabled)
+                                     int sensorsDisabled, int sensorProvider) :
+        LocMsg(), mAdapter(adapter), mSensorsDisabled(sensorsDisabled),
+        mSensorProvider(sensorProvider)
     {
         locallog();
     }
     inline virtual void proc() const {
-        mAdapter->setSensorControlConfig(mSensorsDisabled);
+        mAdapter->setSensorControlConfig(mSensorsDisabled, mSensorProvider);
     }
     inline  void locallog() const {
-        LOC_LOGV("LocEngSensorControlConfig - Sensors Disabled: %d",
-                 mSensorsDisabled);
+        LOC_LOGV("LocEngSensorControlConfig - Sensors Disabled: %d, Sensor Provider: %d",
+                 mSensorsDisabled, mSensorProvider);
     }
     inline virtual void log() const {
         locallog();
@@ -702,7 +749,8 @@ void LocEngReportPosition::proc() const {
             //   2.2.3 the inaccuracy exceeds our tolerance
             else if ((LOC_SESS_SUCCESS == mStatus &&
                       ((LOC_POS_TECH_MASK_SATELLITE |
-                        LOC_POS_TECH_MASK_SENSORS) &
+                        LOC_POS_TECH_MASK_SENSORS   |
+                        LOC_POS_TECH_MASK_HYBRID) &
                        mTechMask)) ||
                      (LOC_SESS_INTERMEDIATE == locEng->intermediateFix &&
                       !((mLocation.gpsLocation.flags &
@@ -731,7 +779,10 @@ void LocEngReportPosition::proc() const {
         }
 
         if (locEng->generateNmea &&
-            mLocation.position_source == ULP_LOCATION_IS_FROM_GNSS)
+            mLocation.position_source == ULP_LOCATION_IS_FROM_GNSS &&
+            mTechMask & (LOC_POS_TECH_MASK_SATELLITE |
+                         LOC_POS_TECH_MASK_SENSORS |
+                         LOC_POS_TECH_MASK_HYBRID))
         {
             unsigned char generate_nmea = reported &&
                                           (mStatus != LOC_SESS_FAILURE);
@@ -822,15 +873,16 @@ void LocEngReportSv::send() const {
 }
 
 //        case LOC_ENG_MSG_REPORT_STATUS:
-LocEngReportStatus::LocEngReportStatus(void* locEng,
+LocEngReportStatus::LocEngReportStatus(LocAdapterBase* adapter,
                                        GpsStatusValue engineStatus) :
-    LocMsg(),  mLocEng(locEng), mStatus(engineStatus)
+    LocMsg(),  mAdapter(adapter), mStatus(engineStatus)
 {
     locallog();
 }
 inline void LocEngReportStatus::proc() const
 {
-    loc_eng_data_s_type* locEng = (loc_eng_data_s_type*) mLocEng;
+    LocEngAdapter* adapter = (LocEngAdapter*)mAdapter;
+    loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)adapter->getOwner();
 
     loc_eng_report_status(*locEng, mStatus);
     update_aiding_data_for_deletion(*locEng);
@@ -857,7 +909,9 @@ void LocEngReportNmea::proc() const {
     gettimeofday(&tv, (struct timezone *) NULL);
     int64_t now = tv.tv_sec * 1000LL + tv.tv_usec / 1000;
     CALLBACK_LOG_CALLFLOW("nmea_cb", %d, mLen);
-    locEng->nmea_cb(now, mNmea, mLen);
+
+    if (locEng->nmea_cb != NULL)
+        locEng->nmea_cb(now, mNmea, mLen);
 }
 inline void LocEngReportNmea::locallog() const {
     LOC_LOGV("LocEngReportNmea");
@@ -875,6 +929,7 @@ LocEngReportXtraServer::LocEngReportXtraServer(void* locEng,
     LocMsg(), mLocEng(locEng), mMaxLen(maxlength),
     mServers(new char[3*(mMaxLen+1)])
 {
+    memset(mServers, 0, 3*(mMaxLen+1));
     strlcpy(mServers, url1, mMaxLen);
     strlcpy(&(mServers[mMaxLen+1]), url2, mMaxLen);
     strlcpy(&(mServers[(mMaxLen+1)<<1]), url3, mMaxLen);
@@ -896,7 +951,7 @@ void LocEngReportXtraServer::proc() const {
 inline void LocEngReportXtraServer::locallog() const {
     LOC_LOGV("LocEngReportXtraServers: server1: %s\n  server2: %s\n"
              "  server3: %s\n",
-             mServers, &mServers[mMaxLen], &mServers[mMaxLen<<1]);
+             mServers, &mServers[mMaxLen+1], &mServers[(mMaxLen+1)<<1]);
 }
 inline void LocEngReportXtraServer::log() const {
     locallog();
@@ -931,10 +986,10 @@ void LocEngReqRelBIT::proc() const {
 }
 inline void LocEngReqRelBIT::locallog() const {
     LOC_LOGV("LocEngRequestBIT - ipv4: %d.%d.%d.%d, ipv6: %s",
-             (unsigned char)(mIPv4Addr>>24),
-             (unsigned char)(mIPv4Addr>>16),
-             (unsigned char)(mIPv4Addr>>8),
              (unsigned char)mIPv4Addr,
+             (unsigned char)(mIPv4Addr>>8),
+             (unsigned char)(mIPv4Addr>>16),
+             (unsigned char)(mIPv4Addr>>24),
              NULL != mIPv6Addr ? mIPv6Addr : "");
 }
 inline void LocEngReqRelBIT::log() const {
@@ -980,8 +1035,10 @@ LocEngSuplEsOpened::LocEngSuplEsOpened(void* locEng) :
 }
 void LocEngSuplEsOpened::proc() const {
     loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
-    AgpsStateMachine* sm = locEng->ds_nif;
-    sm->onRsrcEvent(RSRC_GRANTED);
+    if (locEng->ds_nif) {
+        AgpsStateMachine* sm = locEng->ds_nif;
+        sm->onRsrcEvent(RSRC_GRANTED);
+    }
 }
 void LocEngSuplEsOpened::locallog() const {
     LOC_LOGV("LocEngSuplEsOpened");
@@ -997,6 +1054,450 @@ LocEngSuplEsClosed::LocEngSuplEsClosed(void* locEng) :
 }
 void LocEngSuplEsClosed::proc() const {
     loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
+    if (locEng->ds_nif) {
+        AgpsStateMachine* sm = locEng->ds_nif;
+        sm->onRsrcEvent(RSRC_RELEASED);
+    }
+}
+void LocEngSuplEsClosed::locallog() const {
+    LOC_LOGV("LocEngSuplEsClosed");
+}
+void LocEngSuplEsClosed::log() const {
+    locallog();
+}
+
+
+//        case LOC_ENG_MSG_REQUEST_SUPL_ES:
+LocEngRequestSuplEs::LocEngRequestSuplEs(void* locEng, int id) :
+    LocMsg(), mLocEng(locEng), mID(id) {
+    locallog();
+}
+void LocEngRequestSuplEs::proc() const {
+    loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
+    if (locEng->ds_nif) {
+        AgpsStateMachine* sm = locEng->ds_nif;
+        DSSubscriber s(sm, mID);
+        sm->subscribeRsrc((Subscriber*)&s);
+    } else {
+        locEng->adapter->atlOpenStatus(mID, 0, NULL, -1, -1);
+    }
+}
+inline void LocEngRequestSuplEs::locallog() const {
+    LOC_LOGV("LocEngRequestSuplEs");
+}
+inline void LocEngRequestSuplEs::log() const {
+    locallog();
+}
+
+//        case LOC_ENG_MSG_REQUEST_ATL:
+LocEngRequestATL::LocEngRequestATL(void* locEng, int id,
+                                   AGpsExtType agps_type) :
+    LocMsg(), mLocEng(locEng), mID(id), mType(agps_type) {
+    locallog();
+}
+void LocEngRequestATL::proc() const {
+    loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
+    AgpsStateMachine* sm = (AgpsStateMachine*)
+                           getAgpsStateMachine(*locEng, mType);
+    if (sm) {
+        ATLSubscriber s(mID,
+                        sm,
+                        locEng->adapter,
+                        AGPS_TYPE_INVALID == mType);
+        sm->subscribeRsrc((Subscriber*)&s);
+    } else {
+        locEng->adapter->atlOpenStatus(mID, 0, NULL, -1, mType);
+    }
+}
+inline void LocEngRequestATL::locallog() const {
+    LOC_LOGV("LocEngRequestATL");
+}
+inline void LocEngRequestATL::log() const {
+    locallog();
+}
+
+//        case LOC_ENG_MSG_RELEASE_ATL:
+LocEngReleaseATL::LocEngReleaseATL(void* locEng, int id) :
+    LocMsg(), mLocEng(locEng), mID(id) {
+    locallog();
+}
+void LocEngReleaseATL::proc() const {
+    loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
+
+   if (locEng->agnss_nif) {
+        ATLSubscriber s1(mID, locEng->agnss_nif, locEng->adapter, false);
+        if (locEng->agnss_nif->unsubscribeRsrc((Subscriber*)&s1)) {
+            LOC_LOGD("%s:%d]: Unsubscribed from agnss_nif",
+                     __func__, __LINE__);
+            return;
+        }
+    }
+
+    if (locEng->internet_nif) {
+        ATLSubscriber s2(mID, locEng->internet_nif, locEng->adapter, false);
+        if (locEng->internet_nif->unsubscribeRsrc((Subscriber*)&s2)) {
+            LOC_LOGD("%s:%d]: Unsubscribed from internet_nif",
+                     __func__, __LINE__);
+            return;
+        }
+    }
+
+    if (locEng->ds_nif) {
+        DSSubscriber s3(locEng->ds_nif, mID);
+        if (locEng->ds_nif->unsubscribeRsrc((Subscriber*)&s3)) {
+            LOC_LOGD("%s:%d]: Unsubscribed from ds_nif",
+                     __func__, __LINE__);
+            return;
+        }
+    }
+
+    LOC_LOGW("%s:%d]: Could not release ATL. "
+             "No subscribers found\n",
+             __func__, __LINE__);
+    locEng->adapter->atlCloseStatus(mID, 0);
+}
+inline void LocEngReleaseATL::locallog() const {
+    LOC_LOGV("LocEngReleaseATL");
+}
+inline void LocEngReleaseATL::log() const {
+    locallog();
+}
+
+//        case LOC_ENG_MSG_REQUEST_WIFI:
+//        case LOC_ENG_MSG_RELEASE_WIFI:
+LocEngReqRelWifi::LocEngReqRelWifi(void* locEng, AGpsExtType type,
+                                   loc_if_req_sender_id_e_type sender_id,
+                                   char* s, char* p, bool isReq) :
+    LocMsg(), mLocEng(locEng), mType(type), mSenderId(sender_id),
+    mSSID(NULL == s ? NULL : new char[SSID_BUF_SIZE]),
+    mPassword(NULL == p ? NULL : new char[SSID_BUF_SIZE]),
+    mIsReq(isReq) {
+    if (NULL != s)
+        strlcpy(mSSID, s, SSID_BUF_SIZE);
+    if (NULL != p)
+        strlcpy(mPassword, p, SSID_BUF_SIZE);
+    locallog();
+}
+LocEngReqRelWifi::~LocEngReqRelWifi() {
+    if (NULL != mSSID) {
+        delete[] mSSID;
+    }
+    if (NULL != mPassword) {
+        delete[] mPassword;
+    }
+}
+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);
+    }
+}
+inline void LocEngReqRelWifi::locallog() const {
+    LOC_LOGV("%s - senderId: %d, ssid: %s, password: %s",
+             mIsReq ? "LocEngRequestWifi" : "LocEngReleaseWifi",
+             mSenderId,
+             NULL != mSSID ? mSSID : "",
+             NULL != mPassword ? mPassword : "");
+}
+inline void LocEngReqRelWifi::log() const {
+    locallog();
+}
+void LocEngReqRelWifi::send() const {
+    loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
+    locEng->adapter->sendMsg(this);
+}
+
+//        case LOC_ENG_MSG_REQUEST_XTRA_DATA:
+LocEngRequestXtra::LocEngRequestXtra(void* locEng) :
+    mLocEng(locEng) {
+    locallog();
+}
+void LocEngRequestXtra::proc() const
+{
+    loc_eng_xtra_data_s_type* locEngXtra =
+        &(((loc_eng_data_s_type*)mLocEng)->xtra_module_data);
+
+    if (locEngXtra->download_request_cb != NULL) {
+        CALLBACK_LOG_CALLFLOW("download_request_cb", %p, mLocEng);
+        locEngXtra->download_request_cb();
+    } else {
+        LOC_LOGE("Callback function for request xtra is NULL");
+    }
+}
+inline void LocEngRequestXtra::locallog() const {
+    LOC_LOGV("LocEngReqXtra");
+}
+inline void LocEngRequestXtra::log() const {
+    locallog();
+}
+
+//        case LOC_ENG_MSG_REQUEST_TIME:
+LocEngRequestTime::LocEngRequestTime(void* locEng) :
+    LocMsg(), mLocEng(locEng)
+{
+    locallog();
+}
+void LocEngRequestTime::proc() const {
+    loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
+    if (gps_conf.CAPABILITIES & GPS_CAPABILITY_ON_DEMAND_TIME) {
+        if (locEng->request_utc_time_cb != NULL) {
+            locEng->request_utc_time_cb();
+        } else {
+            LOC_LOGE("Callback function for request time is NULL");
+        }
+    }
+}
+inline void LocEngRequestTime::locallog() const {
+    LOC_LOGV("LocEngReqTime");
+}
+inline void LocEngRequestTime::log() const {
+    locallog();
+}
+
+//        case LOC_ENG_MSG_DELETE_AIDING_DATA:
+struct LocEngDelAidData : public LocMsg {
+    loc_eng_data_s_type* mLocEng;
+    const GpsAidingData mType;
+    inline LocEngDelAidData(loc_eng_data_s_type* locEng,
+                            GpsAidingData f) :
+        LocMsg(), mLocEng(locEng), mType(f)
+    {
+        locallog();
+    }
+    inline virtual void proc() const {
+        mLocEng->aiding_data_for_deletion = mType;
+        update_aiding_data_for_deletion(*mLocEng);
+    }
+    inline void locallog() const {
+        LOC_LOGV("aiding data msak %d", mType);
+    }
+    virtual void log() const {
+        locallog();
+    }
+};
+
+//        case LOC_ENG_MSG_ENABLE_DATA:
+struct LocEngEnableData : public LocMsg {
+    LocEngAdapter* mAdapter;
+    const int mEnable;
+    char* mAPN;
+    const int mLen;
+    inline LocEngEnableData(LocEngAdapter* adapter,
+                            const char* name, int len, int enable) :
+        LocMsg(), mAdapter(adapter),
+        mEnable(enable), mAPN(NULL), mLen(len)
+    {
+        if (NULL != name) {
+            mAPN = new char[len+1];
+            memcpy((void*)mAPN, (void*)name, len);
+            mAPN[len] = 0;
+        }
+        locallog();
+    }
+    inline ~LocEngEnableData() {
+        if (NULL != mAPN) {
+            delete[] mAPN;
+        }
+    }
+    inline virtual void proc() const {
+        mAdapter->enableData(mEnable);
+        if (NULL != mAPN) {
+            mAdapter->setAPN(mAPN, mLen);
+        }
+    }
+    inline void locallog() const {
+        LOC_LOGV("apn: %s\n  enable: %d",
+                 (NULL == mAPN) ? "NULL" : mAPN, mEnable);
+    }
+    inline virtual void log() const {
+        locallog();
+    }
+};
+
+//        case LOC_ENG_MSG_INJECT_XTRA_DATA:
+// loc_eng_xtra.cpp
+
+//        case LOC_ENG_MSG_LOC_INIT:
+struct LocEngInit : public LocMsg {
+    loc_eng_data_s_type* mLocEng;
+    inline LocEngInit(loc_eng_data_s_type* locEng) :
+        LocMsg(), mLocEng(locEng)
+    {
+        locallog();
+    }
+    inline virtual void proc() const {
+        loc_eng_reinit(*mLocEng);
+    }
+    inline void locallog() const
+    {
+        LOC_LOGV("LocEngInit");
+    }
+    inline virtual void log() const
+    {
+        locallog();
+    }
+};
+
+//        case LOC_ENG_MSG_REQUEST_XTRA_SERVER:
+// loc_eng_xtra.cpp
+
+//        case LOC_ENG_MSG_ATL_OPEN_SUCCESS:
+struct LocEngAtlOpenSuccess : public LocMsg {
+    AgpsStateMachine* mStateMachine;
+    const int mLen;
+    char* mAPN;
+    const AGpsBearerType mBearerType;
+    inline LocEngAtlOpenSuccess(AgpsStateMachine* statemachine,
+                                const char* name,
+                                int len,
+                                AGpsBearerType btype) :
+        LocMsg(),
+        mStateMachine(statemachine), mLen(len),
+        mAPN(new char[len+1]), mBearerType(btype)
+    {
+        memcpy((void*)mAPN, (void*)name, len);
+        mAPN[len] = 0;
+        locallog();
+    }
+    inline ~LocEngAtlOpenSuccess()
+    {
+        delete[] mAPN;
+    }
+    inline virtual void proc() const {
+        mStateMachine->setBearer(mBearerType);
+        mStateMachine->setAPN(mAPN, mLen);
+        mStateMachine->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()),
+                 mAPN,
+                 loc_get_agps_bear_name(mBearerType));
+    }
+    inline virtual void log() const {
+        locallog();
+    }
+};
+
+//        case LOC_ENG_MSG_ATL_CLOSED:
+struct LocEngAtlClosed : public LocMsg {
+    AgpsStateMachine* mStateMachine;
+    inline LocEngAtlClosed(AgpsStateMachine* statemachine) :
+        LocMsg(), mStateMachine(statemachine) {
+        locallog();
+    }
+    inline virtual void proc() const {
+        mStateMachine->onRsrcEvent(RSRC_RELEASED);
+    }
+    inline void locallog() const {
+        LOC_LOGV("LocEngAtlClosed");
+    }
+    inline virtual void log() const {
+        locallog();
+    }
+};
+
+//        case LOC_ENG_MSG_ATL_OPEN_FAILED:
+struct LocEngAtlOpenFailed : public LocMsg {
+    AgpsStateMachine* mStateMachine;
+    inline LocEngAtlOpenFailed(AgpsStateMachine* statemachine) :
+        LocMsg(), mStateMachine(statemachine) {
+        locallog();
+    }
+    inline virtual void proc() const {
+        mStateMachine->onRsrcEvent(RSRC_DENIED);
+    }
+    inline void locallog() const {
+        LOC_LOGV("LocEngAtlOpenFailed");
+    }
+    inline virtual void log() const {
+        locallog();
+    }
+};
+
+//        case LOC_ENG_MSG_ENGINE_DOWN:
+LocEngDown::LocEngDown(void* locEng) :
+    LocMsg(), mLocEng(locEng) {
+    locallog();
+}
+inline void LocEngDown::proc() const {
+    loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
+    loc_eng_handle_engine_down(*locEng);
+}
+inline void LocEngDown::locallog() const {
+    LOC_LOGV("LocEngDown");
+}
+inline void LocEngDown::log() const {
+    locallog();
+}
+
+//        case LOC_ENG_MSG_ENGINE_UP:
+LocEngUp::LocEngUp(void* locEng) :
+    LocMsg(), mLocEng(locEng) {
+    locallog();
+}
+inline void LocEngUp::proc() const {
+    loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
+    loc_eng_handle_engine_up(*locEng);
+}
+inline void LocEngUp::locallog() const {
+    LOC_LOGV("LocEngUp");
+}
+inline void LocEngUp::log() const {
+    locallog();
+}
+
+struct LocEngDataClientInit : public LocMsg {
+    loc_eng_data_s_type* mLocEng;
+    inline LocEngDataClientInit(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);
+        }
+    }
+    void locallog() const {
+        LOC_LOGV("LocEngDataClientInit\n");
+    }
+    virtual void log() const {
+        locallog();
+    }
+};
+
+
+/*********************************************************************
+ * Initialization checking macros
+ *********************************************************************/
+#define STATE_CHECK(ctx, x, ret) \
+    if (!(ctx))                  \
+  {                              \
+      /* Not intialized, abort */\
+      LOC_LOGE("%s: log_eng state error: %s", __func__, x); \
+      EXIT_LOG(%s, x);                                            \
+      ret;                                                        \
+  }
+#define INIT_CHECK(ctx, ret) STATE_CHECK(ctx, "instance not initialized", ret)
+
+//        LocEngSuplEsClosed
+LocEngSuplEsClosed::LocEngSuplEsClosed(void* locEng) :
+    LocMsg(), mLocEng(locEng) {
+    locallog();
+}
+void LocEngSuplEsClosed::proc() const {
+    loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
     AgpsStateMachine* sm = locEng->ds_nif;
     sm->onRsrcEvent(RSRC_RELEASED);
 }
@@ -1403,7 +1904,7 @@ SIDE EFFECTS
 
 ===========================================================================*/
 int loc_eng_init(loc_eng_data_s_type &loc_eng_data, LocCallbacks* callbacks,
-                 LOC_API_ADAPTER_EVENT_MASK_T event)
+                 LOC_API_ADAPTER_EVENT_MASK_T event, ContextBase* context)
 
 {
     int ret_val = 0;
@@ -1438,7 +1939,7 @@ int loc_eng_init(loc_eng_data_s_type &loc_eng_data, LocCallbacks* callbacks,
     loc_eng_data.sv_ext_parser = callbacks->sv_ext_parser ?
         callbacks->sv_ext_parser : noProc;
     loc_eng_data.intermediateFix = gps_conf.INTERMEDIATE_POS;
-
+    loc_eng_data.shutdown_cb = callbacks->shutdown_cb;
     // initial states taken care of by the memset above
     // loc_eng_data.engine_status -- GPS_STATUS_NONE;
     // loc_eng_data.fix_session_status -- GPS_STATUS_NONE;
@@ -1454,12 +1955,13 @@ int loc_eng_init(loc_eng_data_s_type &loc_eng_data, LocCallbacks* callbacks,
         loc_eng_data.generateNmea = false;
     }
 
-    //Disable AGPS if capabilities are not present
-    if(!(gps_conf.CAPABILITIES & GPS_CAPABILITY_MSA) &&
-       !(gps_conf.CAPABILITIES & GPS_CAPABILITY_MSB)) {
-        event &= ~(LOC_API_ADAPTER_BIT_LOCATION_SERVER_REQUEST |
-                   LOC_API_ADAPTER_BIT_NI_NOTIFY_VERIFY_REQUEST);
-    }
+    loc_eng_data.adapter =
+        new LocEngAdapter(event, &loc_eng_data, context,
+                          (MsgTask::tCreate)callbacks->create_thread_cb);
+
+    LOC_LOGD("loc_eng_init created client, id = %p\n",
+             loc_eng_data.adapter);
+    loc_eng_data.adapter->sendMsg(new LocEngInit(&loc_eng_data));
 
     loc_eng_data.adapter =
         new LocEngAdapter(event, &loc_eng_data,
@@ -1485,7 +1987,8 @@ static int loc_eng_reinit(loc_eng_data_s_type &loc_eng_data)
         LocEngAdapter* adapter = loc_eng_data.adapter;
         adapter->sendMsg(new LocEngSuplVer(adapter, gps_conf.SUPL_VER));
         adapter->sendMsg(new LocEngLppConfig(adapter, gps_conf.LPP_PROFILE));
-        adapter->sendMsg(new LocEngSensorControlConfig(adapter, sap_conf.SENSOR_USAGE));
+        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));
 
         /* Make sure at least one of the sensor property is specified by the user in the gps.conf file. */
@@ -1728,6 +2231,16 @@ int loc_eng_set_position_mode(loc_eng_data_s_type &loc_eng_data,
     ENTRY_LOG_CALLFLOW();
     INIT_CHECK(loc_eng_data.adapter, return -1);
 
+    int gnssType = getTargetGnssType(loc_get_target());
+
+    // The position mode for GSS/QCA1530 can only be standalone
+    bool is1530 = gnssType == GNSS_QCA1530;
+    bool isAPQ = gnssType == GNSS_GSS;
+    if ((isAPQ || is1530) && params.mode != LOC_POSITION_MODE_STANDALONE) {
+        params.mode = LOC_POSITION_MODE_STANDALONE;
+        LOC_LOGD("Position mode changed to standalone for target with GSS/qca1530.");
+    }
+
     if(! loc_eng_data.adapter->getUlpProxy()->sendFixMode(params))
     {
         LocEngAdapter* adapter = loc_eng_data.adapter;
@@ -1760,10 +2273,10 @@ int loc_eng_inject_time(loc_eng_data_s_type &loc_eng_data, GpsUtcTime time,
     ENTRY_LOG_CALLFLOW();
     INIT_CHECK(loc_eng_data.adapter, return -1);
     LocEngAdapter* adapter = loc_eng_data.adapter;
-    if (adapter->mAgpsEnabled) {
-        adapter->sendMsg(new LocEngSetTime(adapter, time, timeReference,
-                                           uncertainty));
-    }
+
+    adapter->sendMsg(new LocEngSetTime(adapter, time, timeReference,
+                                       uncertainty));
+
     EXIT_LOG(%d, 0);
     return 0;
 }
@@ -1791,8 +2304,11 @@ int loc_eng_inject_location(loc_eng_data_s_type &loc_eng_data, double latitude,
     ENTRY_LOG_CALLFLOW();
     INIT_CHECK(loc_eng_data.adapter, return -1);
     LocEngAdapter* adapter = loc_eng_data.adapter;
-    adapter->sendMsg(new LocEngInjectLocation(adapter, latitude, longitude,
-                                              accuracy));
+    if(adapter->mSupportsPositionInjection)
+    {
+        adapter->sendMsg(new LocEngInjectLocation(adapter, latitude, longitude,
+                                                  accuracy));
+    }
 
     EXIT_LOG(%d, 0);
     return 0;
@@ -1861,6 +2377,32 @@ static void loc_inform_gps_status(loc_eng_data_s_type &loc_eng_data, GpsStatusVa
     EXIT_LOG(%s, VOID_RET);
 }
 
+static int loc_eng_get_zpp_handler(loc_eng_data_s_type &loc_eng_data)
+{
+   ENTRY_LOG();
+   int ret_val = LOC_API_ADAPTER_ERR_SUCCESS;
+   UlpLocation location;
+   LocPosTechMask tech_mask = LOC_POS_TECH_MASK_DEFAULT;
+   GpsLocationExtended locationExtended;
+   memset(&locationExtended, 0, sizeof (GpsLocationExtended));
+   locationExtended.size = sizeof(locationExtended);
+   memset(&location, 0, sizeof location);
+
+   ret_val = loc_eng_data.adapter->getZpp(location.gpsLocation, tech_mask);
+  //Mark the location source as from ZPP
+  location.gpsLocation.flags |= LOCATION_HAS_SOURCE_INFO;
+  location.position_source = ULP_LOCATION_IS_FROM_ZPP;
+
+  loc_eng_data.adapter->getUlpProxy()->reportPosition(location,
+                                     locationExtended,
+                                     NULL,
+                                     LOC_SESS_SUCCESS,
+                                     tech_mask);
+
+  EXIT_LOG(%d, ret_val);
+  return ret_val;
+}
+
 /*
   Callback function passed to Data Services State Machine
   This becomes part of the state machine's servicer and
@@ -1952,28 +2494,14 @@ void loc_eng_agps_init(loc_eng_data_s_type &loc_eng_data, AGpsExtCallbacks* call
     STATE_CHECK((NULL == loc_eng_data.agps_status_cb),
                 "agps instance already initialized",
                 return);
-    if(callbacks == NULL) {
+    if (callbacks == NULL) {
         LOC_LOGE("loc_eng_agps_init: bad parameters cb %p", callbacks);
         EXIT_LOG(%s, VOID_RET);
         return;
     }
-
-    //Proceed to create AGPS framework only if MSA or MSB capabilities
-    //are present. If the target is an APQ, these masks are
-    //cleared in get_gps_interface()
-    if(!(gps_conf.CAPABILITIES & GPS_CAPABILITY_MSA) &&
-       !(gps_conf.CAPABILITIES & GPS_CAPABILITY_MSB) ) {
-        LOC_LOGD("%s:%d]: No AGPS capabilities found. Returning\n",
-                 __func__, __LINE__);
-        return;
-    }
-
+    LocEngAdapter* adapter = loc_eng_data.adapter;
     loc_eng_data.agps_status_cb = callbacks->status_cb;
 
-    loc_eng_data.agnss_nif = new AgpsStateMachine(servicerTypeAgps,
-                                                  (void *)loc_eng_data.agps_status_cb,
-                                                  AGPS_TYPE_SUPL,
-                                                  false);
     loc_eng_data.internet_nif = new AgpsStateMachine(servicerTypeAgps,
                                                      (void *)loc_eng_data.agps_status_cb,
                                                      AGPS_TYPE_WWAN_ANY,
@@ -1982,18 +2510,25 @@ void loc_eng_agps_init(loc_eng_data_s_type &loc_eng_data, AGpsExtCallbacks* call
                                                  (void *)loc_eng_data.agps_status_cb,
                                                  AGPS_TYPE_WIFI,
                                                  true);
-    if(!loc_eng_data.adapter->initDataServiceClient()) {
-        LOC_LOGD("%s:%d]: Creating new ds state machine\n", __func__, __LINE__);
-        loc_eng_data.ds_nif = new DSStateMachine(servicerTypeExt,
-                                                 (void *)dataCallCb,
-                                                 loc_eng_data.adapter);
-        LOC_LOGD("%s:%d]: Created new ds state machine\n", __func__, __LINE__);
-    }
 
-    //loc_eng_dmn_conn_loc_api_server_launch(callbacks->create_thread_cb,
-    //                                               NULL, NULL, &loc_eng_data);
+    int gnssType = getTargetGnssType(loc_get_target());
+    bool isAPQ = (gnssType == GNSS_GSS);
+    bool is1530 = (gnssType == GNSS_QCA1530);
+    if (!isAPQ && !is1530) {
+        loc_eng_data.agnss_nif = new AgpsStateMachine(servicerTypeAgps,
+                                                      (void *)loc_eng_data.agps_status_cb,
+                                                      AGPS_TYPE_SUPL,
+                                                      false);
+
+        if (adapter->mSupportsAgpsRequests) {
+            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);
+        }
+        loc_eng_agps_reinit(loc_eng_data);
+    }
 
-    loc_eng_agps_reinit(loc_eng_data);
     EXIT_LOG(%s, VOID_RET);
 }
 
@@ -2417,9 +2952,13 @@ void loc_eng_handle_engine_up(loc_eng_data_s_type &loc_eng_data)
     ENTRY_LOG();
     loc_eng_reinit(loc_eng_data);
 
+    loc_eng_data.adapter->requestPowerVote();
+
     if (loc_eng_data.agps_status_cb != NULL) {
-        loc_eng_data.agnss_nif->dropAllSubscribers();
-        loc_eng_data.internet_nif->dropAllSubscribers();
+        if (loc_eng_data.agnss_nif)
+            loc_eng_data.agnss_nif->dropAllSubscribers();
+        if (loc_eng_data.internet_nif)
+            loc_eng_data.internet_nif->dropAllSubscribers();
 
         loc_eng_agps_reinit(loc_eng_data);
     }
@@ -2494,3 +3033,27 @@ int loc_eng_read_config(void)
     EXIT_LOG(%d, 0);
     return 0;
 }
+
+/*===========================================================================
+FUNCTION    loc_eng_handle_shutdown
+
+DESCRIPTION
+   Calls the shutdown callback function in the loc interface to close
+   the modem node
+
+DEPENDENCIES
+   None
+
+RETURN VALUE
+   0: success
+
+SIDE EFFECTS
+   N/A
+
+===========================================================================*/
+void loc_eng_handle_shutdown(loc_eng_data_s_type &locEng)
+{
+    ENTRY_LOG();
+    locEng.shutdown_cb();
+    EXIT_LOG(%d, 0);
+}
diff --git a/loc_api/libloc_api_50001/loc_eng.h b/loc_api/libloc_api_50001/loc_eng.h
index d5f1855..ff787da 100644
--- a/loc_api/libloc_api_50001/loc_eng.h
+++ b/loc_api/libloc_api_50001/loc_eng.h
@@ -133,6 +133,7 @@ typedef struct loc_eng_data_s
 
     loc_ext_parser location_ext_parser;
     loc_ext_parser sv_ext_parser;
+    loc_shutdown_cb shutdown_cb;
 } loc_eng_data_s_type;
 
 /* GPS.conf support */
@@ -140,10 +141,8 @@ typedef struct loc_gps_cfg_s
 {
     unsigned long  INTERMEDIATE_POS;
     unsigned long  ACCURACY_THRES;
-    unsigned long  ENABLE_WIPER;
     unsigned long  SUPL_VER;
     unsigned long  CAPABILITIES;
-    unsigned long  QUIPC_ENABLED;
     unsigned long  LPP_PROFILE;
     uint8_t        NMEA_PROVIDER;
     unsigned long  A_GLONASS_POS_PROTOCOL_SELECT;
@@ -172,6 +171,7 @@ typedef struct
     double         RATE_RANDOM_WALK_SPECTRAL_DENSITY;
     uint8_t        VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY_VALID;
     double         VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY;
+    unsigned long  SENSOR_PROVIDER;
 } loc_sap_cfg_s_type;
 
 extern loc_gps_cfg_s_type gps_conf;
@@ -179,7 +179,8 @@ extern loc_sap_cfg_s_type sap_conf;
 
 int  loc_eng_init(loc_eng_data_s_type &loc_eng_data,
                   LocCallbacks* callbacks,
-                  LOC_API_ADAPTER_EVENT_MASK_T event);
+                  LOC_API_ADAPTER_EVENT_MASK_T event,
+                  ContextBase* context);
 int  loc_eng_start(loc_eng_data_s_type &loc_eng_data);
 int  loc_eng_stop(loc_eng_data_s_type &loc_eng_data);
 void loc_eng_cleanup(loc_eng_data_s_type &loc_eng_data);
diff --git a/loc_api/libloc_api_50001/loc_eng_dmn_conn.h b/loc_api/libloc_api_50001/loc_eng_dmn_conn.h
index c7c100b..1d8c142 100644
--- a/loc_api/libloc_api_50001/loc_eng_dmn_conn.h
+++ b/loc_api/libloc_api_50001/loc_eng_dmn_conn.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2011-2012, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2011-2012,2014 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,11 +33,11 @@
 
 #ifdef _ANDROID_
 
-#define GPSONE_LOC_API_Q_PATH "/data/misc/gpsone_d/gpsone_loc_api_q"
-#define GPSONE_LOC_API_RESP_Q_PATH "/data/misc/gpsone_d/gpsone_loc_api_resp_q"
-#define QUIPC_CTRL_Q_PATH "/data/misc/gpsone_d/quipc_ctrl_q"
-#define MSAPM_CTRL_Q_PATH "/data/misc/gpsone_d/msapm_ctrl_q"
-#define MSAPU_CTRL_Q_PATH "/data/misc/gpsone_d/msapu_ctrl_q"
+#define GPSONE_LOC_API_Q_PATH "/data/misc/location/gpsone_d/gpsone_loc_api_q"
+#define GPSONE_LOC_API_RESP_Q_PATH "/data/misc/location/gpsone_d/gpsone_loc_api_resp_q"
+#define QUIPC_CTRL_Q_PATH "/data/misc/location/gpsone_d/quipc_ctrl_q"
+#define MSAPM_CTRL_Q_PATH "/data/misc/location/gpsone_d/msapm_ctrl_q"
+#define MSAPU_CTRL_Q_PATH "/data/misc/location/gpsone_d/msapu_ctrl_q"
 
 #else
 
diff --git a/loc_api/libloc_api_50001/loc_eng_msg.h b/loc_api/libloc_api_50001/loc_eng_msg.h
index 1a31894..b767dc5 100644
--- a/loc_api/libloc_api_50001/loc_eng_msg.h
+++ b/loc_api/libloc_api_50001/loc_eng_msg.h
@@ -119,9 +119,9 @@ struct LocEngReportSv : public LocMsg {
 };
 
 struct LocEngReportStatus : public LocMsg {
-    void* mLocEng;
+    LocAdapterBase* mAdapter;
     const GpsStatusValue mStatus;
-    LocEngReportStatus(void* locEng,
+    LocEngReportStatus(LocAdapterBase* adapter,
                        GpsStatusValue engineStatus);
     virtual void proc() const;
     void locallog() const;
@@ -280,7 +280,22 @@ struct LocEngUp : public LocMsg {
     virtual void log() const;
 };
 
+struct LocEngGetZpp : public LocMsg {
+    LocEngAdapter* mAdapter;
+    LocEngGetZpp(LocEngAdapter* adapter);
+    virtual void proc() const;
+    void locallog() const;
+    virtual void log() const;
+    void send() const;
+};
 
+struct LocEngShutdown : public LocMsg {
+    LocEngAdapter* mAdapter;
+    LocEngShutdown(LocEngAdapter* adapter);
+    virtual void proc() const;
+    void locallog() const;
+    virtual void log() const;
+};
 #ifdef __cplusplus
 }
 #endif /* __cplusplus */
diff --git a/loc_api/libloc_api_50001/loc_eng_ni.cpp b/loc_api/libloc_api_50001/loc_eng_ni.cpp
index f017cab..4597b98 100644
--- a/loc_api/libloc_api_50001/loc_eng_ni.cpp
+++ b/loc_api/libloc_api_50001/loc_eng_ni.cpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2009-2013, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2009-2014, 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
@@ -116,28 +116,45 @@ void loc_eng_ni_request_handler(loc_eng_data_s_type &loc_eng_data,
     ENTRY_LOG();
     char lcs_addr[32]; // Decoded LCS address for UMTS CP NI
     loc_eng_ni_data_s_type* loc_eng_ni_data_p = &loc_eng_data.loc_eng_ni_data;
+    loc_eng_ni_session_s_type* pSession = NULL;
 
     if (NULL == loc_eng_data.ni_notify_cb) {
         EXIT_LOG(%s, "loc_eng_ni_init hasn't happened yet.");
         return;
     }
 
-    /* If busy, use default or deny */
-    if (NULL != loc_eng_ni_data_p->rawRequest)
-    {
-        /* XXX Consider sending a NO RESPONSE reply or queue the request */
-        LOC_LOGW("loc_eng_ni_request_handler, notification in progress, new NI request ignored, type: %d",
-                 notif->ni_type);
-        if (NULL != passThrough) {
-            free((void*)passThrough);
+    if (notif->ni_type == GPS_NI_TYPE_EMERGENCY_SUPL) {
+        if (NULL != loc_eng_ni_data_p->sessionEs.rawRequest) {
+            LOC_LOGW("loc_eng_ni_request_handler, supl es NI in progress, new supl es NI ignored, type: %d",
+                     notif->ni_type);
+            if (NULL != passThrough) {
+                free((void*)passThrough);
+            }
+        } else {
+            pSession = &loc_eng_ni_data_p->sessionEs;
+        }
+    } else {
+        if (NULL != loc_eng_ni_data_p->session.rawRequest ||
+            NULL != loc_eng_ni_data_p->sessionEs.rawRequest) {
+            LOC_LOGW("loc_eng_ni_request_handler, supl NI in progress, new supl NI ignored, type: %d",
+                     notif->ni_type);
+            if (NULL != passThrough) {
+                free((void*)passThrough);
+            }
+        } else {
+            pSession = &loc_eng_ni_data_p->session;
         }
     }
-    else {
+
+
+    if (pSession) {
         /* Save request */
-        loc_eng_ni_data_p->rawRequest = (void*)passThrough;
+        pSession->rawRequest = (void*)passThrough;
+        pSession->reqID = ++loc_eng_ni_data_p->reqIDCounter;
+        pSession->adapter = loc_eng_data.adapter;
 
         /* Fill in notification */
-        ((GpsNiNotification*)notif)->notification_id = loc_eng_ni_data_p->reqID;
+        ((GpsNiNotification*)notif)->notification_id = pSession->reqID;
 
         if (notif->notify_flags == GPS_NI_PRIVACY_OVERRIDE)
         {
@@ -156,16 +173,16 @@ void loc_eng_ni_request_handler(loc_eng_data_s_type &loc_eng_data,
         /* For robustness, spawn a thread at this point to timeout to clear up the notification status, even though
          * the OEM layer in java does not do so.
          **/
-        loc_eng_ni_data_p->respTimeLeft = 5 + (notif->timeout != 0 ? notif->timeout : LOC_NI_NO_RESPONSE_TIME);
-        LOC_LOGI("Automatically sends 'no response' in %d seconds (to clear status)\n", loc_eng_ni_data_p->respTimeLeft);
+        pSession->respTimeLeft = 5 + (notif->timeout != 0 ? notif->timeout : LOC_NI_NO_RESPONSE_TIME);
+        LOC_LOGI("Automatically sends 'no response' in %d seconds (to clear status)\n", pSession->respTimeLeft);
 
         int rc = 0;
-        rc = pthread_create(&loc_eng_ni_data_p->thread, NULL, ni_thread_proc, &loc_eng_data);
+        rc = pthread_create(&pSession->thread, NULL, ni_thread_proc, pSession);
         if (rc)
         {
             LOC_LOGE("Loc NI thread is not created.\n");
         }
-        rc = pthread_detach(loc_eng_ni_data_p->thread);
+        rc = pthread_detach(pSession->thread);
         if (rc)
         {
             LOC_LOGE("Loc NI thread is not detached.\n");
@@ -186,56 +203,64 @@ static void* ni_thread_proc(void *args)
 {
     ENTRY_LOG();
 
-    loc_eng_data_s_type* loc_eng_data_p = (loc_eng_data_s_type*)args;
-    loc_eng_ni_data_s_type* loc_eng_ni_data_p = &loc_eng_data_p->loc_eng_ni_data;
+    loc_eng_ni_session_s_type* pSession = (loc_eng_ni_session_s_type*)args;
     int rc = 0;          /* return code from pthread calls */
 
     struct timeval present_time;
     struct timespec expire_time;
 
     LOC_LOGD("Starting Loc NI thread...\n");
-    pthread_mutex_lock(&loc_eng_ni_data_p->tLock);
+    pthread_mutex_lock(&pSession->tLock);
     /* Calculate absolute expire time */
     gettimeofday(&present_time, NULL);
-    expire_time.tv_sec  = present_time.tv_sec + loc_eng_ni_data_p->respTimeLeft;
+    expire_time.tv_sec  = present_time.tv_sec + pSession->respTimeLeft;
     expire_time.tv_nsec = present_time.tv_usec * 1000;
     LOC_LOGD("ni_thread_proc-Time out set for abs time %ld with delay %d sec\n",
-             (long) expire_time.tv_sec, loc_eng_ni_data_p->respTimeLeft );
+             (long) expire_time.tv_sec, pSession->respTimeLeft );
 
-    while (!loc_eng_ni_data_p->respRecvd)
+    while (!pSession->respRecvd)
     {
-        rc = pthread_cond_timedwait(&loc_eng_ni_data_p->tCond,
-                                    &loc_eng_ni_data_p->tLock,
+        rc = pthread_cond_timedwait(&pSession->tCond,
+                                    &pSession->tLock,
                                     &expire_time);
         if (rc == ETIMEDOUT)
         {
-            loc_eng_ni_data_p->resp = GPS_NI_RESPONSE_NORESP;
+            pSession->resp = GPS_NI_RESPONSE_NORESP;
             LOC_LOGD("ni_thread_proc-Thread time out after valting for specified time. Ret Val %d\n",rc );
             break;
         }
     }
     LOC_LOGD("ni_thread_proc-Java layer has sent us a user response and return value from "
              "pthread_cond_timedwait = %d\n",rc );
-    loc_eng_ni_data_p->respRecvd = FALSE; /* Reset the user response flag for the next session*/
+    pSession->respRecvd = FALSE; /* Reset the user response flag for the next session*/
+
+    LOC_LOGD("pSession->resp is %d\n",pSession->resp);
 
     // adding this check to support modem restart, in which case, we need the thread
     // to exit without calling sending data. We made sure that rawRequest is NULL in
     // loc_eng_ni_reset_on_engine_restart()
-    LocEngAdapter* adapter = loc_eng_data_p->adapter;
+    LocEngAdapter* adapter = pSession->adapter;
     LocEngInformNiResponse *msg = NULL;
 
-    if (NULL != loc_eng_ni_data_p->rawRequest) {
-        msg = new LocEngInformNiResponse(adapter,
-                                         loc_eng_ni_data_p->resp,
-                                         loc_eng_ni_data_p->rawRequest);
-        loc_eng_ni_data_p->rawRequest = NULL;
+    if (NULL != pSession->rawRequest) {
+        if (pSession->resp != GPS_NI_RESPONSE_IGNORE) {
+            LOC_LOGD("pSession->resp != GPS_NI_RESPONSE_IGNORE \n");
+            msg = new LocEngInformNiResponse(adapter,
+                                             pSession->resp,
+                                             pSession->rawRequest);
+        } else {
+            LOC_LOGD("this is the ignore reply for SUPL ES\n");
+            free(pSession->rawRequest);
+        }
+        pSession->rawRequest = NULL;
     }
-    pthread_mutex_unlock(&loc_eng_ni_data_p->tLock);
+    pthread_mutex_unlock(&pSession->tLock);
 
-    loc_eng_ni_data_p->respTimeLeft = 0;
-    loc_eng_ni_data_p->reqID++;
+    pSession->respTimeLeft = 0;
+    pSession->reqID = 0;
 
     if (NULL != msg) {
+        LOC_LOGD("ni_thread_proc: adapter->sendMsg(msg)\n");
         adapter->sendMsg(msg);
     }
 
@@ -254,16 +279,28 @@ void loc_eng_ni_reset_on_engine_restart(loc_eng_data_s_type &loc_eng_data)
     }
 
     // only if modem has requested but then died.
-    if (NULL != loc_eng_ni_data_p->rawRequest) {
-        free(loc_eng_ni_data_p->rawRequest);
-        loc_eng_ni_data_p->rawRequest = NULL;
+    if (NULL != loc_eng_ni_data_p->sessionEs.rawRequest) {
+        free(loc_eng_ni_data_p->sessionEs.rawRequest);
+        loc_eng_ni_data_p->sessionEs.rawRequest = NULL;
 
-        pthread_mutex_lock(&loc_eng_ni_data_p->tLock);
+        pthread_mutex_lock(&loc_eng_ni_data_p->sessionEs.tLock);
         // the goal is to wake up ni_thread_proc
         // and let it exit.
-        loc_eng_ni_data_p->respRecvd = TRUE;
-        pthread_cond_signal(&loc_eng_ni_data_p->tCond);
-        pthread_mutex_unlock(&loc_eng_ni_data_p->tLock);
+        loc_eng_ni_data_p->sessionEs.respRecvd = TRUE;
+        pthread_cond_signal(&loc_eng_ni_data_p->sessionEs.tCond);
+        pthread_mutex_unlock(&loc_eng_ni_data_p->sessionEs.tLock);
+    }
+
+    if (NULL != loc_eng_ni_data_p->session.rawRequest) {
+        free(loc_eng_ni_data_p->session.rawRequest);
+        loc_eng_ni_data_p->session.rawRequest = NULL;
+
+        pthread_mutex_lock(&loc_eng_ni_data_p->session.tLock);
+        // the goal is to wake up ni_thread_proc
+        // and let it exit.
+        loc_eng_ni_data_p->session.respRecvd = TRUE;
+        pthread_cond_signal(&loc_eng_ni_data_p->session.tCond);
+        pthread_mutex_unlock(&loc_eng_ni_data_p->session.tLock);
     }
 
     EXIT_LOG(%s, VOID_RET);
@@ -297,12 +334,19 @@ void loc_eng_ni_init(loc_eng_data_s_type &loc_eng_data, GpsNiExtCallbacks *callb
         EXIT_LOG(%s, "loc_eng_ni_init: already inited.");
     } else {
         loc_eng_ni_data_s_type* loc_eng_ni_data_p = &loc_eng_data.loc_eng_ni_data;
-        loc_eng_ni_data_p->respTimeLeft = 0;
-        loc_eng_ni_data_p->respRecvd = FALSE;
-        loc_eng_ni_data_p->rawRequest = NULL;
-        loc_eng_ni_data_p->reqID = 0;
-        pthread_cond_init(&loc_eng_ni_data_p->tCond, NULL);
-        pthread_mutex_init(&loc_eng_ni_data_p->tLock, NULL);
+        loc_eng_ni_data_p->sessionEs.respTimeLeft = 0;
+        loc_eng_ni_data_p->sessionEs.respRecvd = FALSE;
+        loc_eng_ni_data_p->sessionEs.rawRequest = NULL;
+        loc_eng_ni_data_p->sessionEs.reqID = 0;
+        pthread_cond_init(&loc_eng_ni_data_p->sessionEs.tCond, NULL);
+        pthread_mutex_init(&loc_eng_ni_data_p->sessionEs.tLock, NULL);
+
+        loc_eng_ni_data_p->session.respTimeLeft = 0;
+        loc_eng_ni_data_p->session.respRecvd = FALSE;
+        loc_eng_ni_data_p->session.rawRequest = NULL;
+        loc_eng_ni_data_p->session.reqID = 0;
+        pthread_cond_init(&loc_eng_ni_data_p->session.tCond, NULL);
+        pthread_mutex_init(&loc_eng_ni_data_p->session.tLock, NULL);
 
         loc_eng_data.ni_notify_cb = callbacks->notify_cb;
         EXIT_LOG(%s, VOID_RET);
@@ -330,25 +374,40 @@ void loc_eng_ni_respond(loc_eng_data_s_type &loc_eng_data,
 {
     ENTRY_LOG_CALLFLOW();
     loc_eng_ni_data_s_type* loc_eng_ni_data_p = &loc_eng_data.loc_eng_ni_data;
+    loc_eng_ni_session_s_type* pSession = NULL;
 
     if (NULL == loc_eng_data.ni_notify_cb) {
         EXIT_LOG(%s, "loc_eng_ni_init hasn't happened yet.");
         return;
     }
 
-    if (notif_id == loc_eng_ni_data_p->reqID &&
-        NULL != loc_eng_ni_data_p->rawRequest)
-    {
+    if (notif_id == loc_eng_ni_data_p->sessionEs.reqID &&
+        NULL != loc_eng_ni_data_p->sessionEs.rawRequest) {
+        pSession = &loc_eng_ni_data_p->sessionEs;
+        // ignore any SUPL NI non-Es session if a SUPL NI ES is accepted
+        if (user_response == GPS_NI_RESPONSE_ACCEPT &&
+            NULL != loc_eng_ni_data_p->session.rawRequest) {
+                pthread_mutex_lock(&loc_eng_ni_data_p->session.tLock);
+                loc_eng_ni_data_p->session.resp = GPS_NI_RESPONSE_IGNORE;
+                loc_eng_ni_data_p->session.respRecvd = TRUE;
+                pthread_cond_signal(&loc_eng_ni_data_p->session.tCond);
+                pthread_mutex_unlock(&loc_eng_ni_data_p->session.tLock);
+        }
+    } else if (notif_id == loc_eng_ni_data_p->session.reqID &&
+        NULL != loc_eng_ni_data_p->session.rawRequest) {
+        pSession = &loc_eng_ni_data_p->session;
+    }
+
+    if (pSession) {
         LOC_LOGI("loc_eng_ni_respond: send user response %d for notif %d", user_response, notif_id);
-        pthread_mutex_lock(&loc_eng_ni_data_p->tLock);
-        loc_eng_ni_data_p->resp = user_response;
-        loc_eng_ni_data_p->respRecvd = TRUE;
-        pthread_cond_signal(&loc_eng_ni_data_p->tCond);
-        pthread_mutex_unlock(&loc_eng_ni_data_p->tLock);
+        pthread_mutex_lock(&pSession->tLock);
+        pSession->resp = user_response;
+        pSession->respRecvd = TRUE;
+        pthread_cond_signal(&pSession->tCond);
+        pthread_mutex_unlock(&pSession->tLock);
     }
     else {
-        LOC_LOGE("loc_eng_ni_respond: reqID %d and notif_id %d mismatch or rawRequest %p, response: %d",
-                 loc_eng_ni_data_p->reqID, notif_id, loc_eng_ni_data_p->rawRequest, user_response);
+        LOC_LOGE("loc_eng_ni_respond: notif_id %d not an active session", notif_id);
     }
 
     EXIT_LOG(%s, VOID_RET);
diff --git a/loc_api/libloc_api_50001/loc_eng_ni.h b/loc_api/libloc_api_50001/loc_eng_ni.h
index 9cbc57d..068f5cd 100644
--- a/loc_api/libloc_api_50001/loc_eng_ni.h
+++ b/loc_api/libloc_api_50001/loc_eng_ni.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2009,2011 The Linux Foundation. All rights reserved.
+/* Copyright (c) 2009,2011,2014 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
@@ -31,9 +31,11 @@
 #define LOC_ENG_NI_H
 
 #include <stdbool.h>
+#include <LocEngAdapter.h>
 
 #define LOC_NI_NO_RESPONSE_TIME            20                      /* secs */
 #define LOC_NI_NOTIF_KEY_ADDRESS           "Address"
+#define GPS_NI_RESPONSE_IGNORE             4
 
 typedef struct {
     pthread_t               thread;            /* NI thread */
@@ -44,6 +46,13 @@ typedef struct {
     GpsUserResponseType     resp;
     pthread_cond_t          tCond;
     pthread_mutex_t         tLock;
+    LocEngAdapter*          adapter;
+} loc_eng_ni_session_s_type;
+
+typedef struct {
+    loc_eng_ni_session_s_type session;    /* SUPL NI Session */
+    loc_eng_ni_session_s_type sessionEs;  /* Emergency SUPL NI Session */
+    int reqIDCounter;
 } loc_eng_ni_data_s_type;
 
 
diff --git a/loc_api/libloc_api_50001/loc_eng_nmea.cpp b/loc_api/libloc_api_50001/loc_eng_nmea.cpp
index f5f746b..842eda1 100644
--- a/loc_api/libloc_api_50001/loc_eng_nmea.cpp
+++ b/loc_api/libloc_api_50001/loc_eng_nmea.cpp
@@ -29,7 +29,10 @@
 
 #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>
@@ -57,7 +60,8 @@ void loc_eng_nmea_send(char *pNmea, int length, loc_eng_data_s_type *loc_eng_dat
     gettimeofday(&tv, (struct timezone *) NULL);
     int64_t now = tv.tv_sec * 1000LL + tv.tv_usec / 1000;
     CALLBACK_LOG_CALLFLOW("nmea_cb", %p, pNmea);
-    loc_eng_data_p->nmea_cb(now, pNmea, length);
+    if (loc_eng_data_p->nmea_cb != NULL)
+        loc_eng_data_p->nmea_cb(now, pNmea, length);
     LOC_LOGD("NMEA <%s", pNmea);
 }
 
@@ -605,12 +609,33 @@ void loc_eng_nmea_generate_sv(loc_eng_data_s_type *loc_eng_data_p,
     char* pMarker = sentence;
     int lengthRemaining = sizeof(sentence);
     int length = 0;
+    int svCount = svStatus.num_svs;
+    int sentenceCount = 0;
+    int sentenceNumber = 1;
+    int svNumber = 1;
+    int gpsCount = 0;
+    int glnCount = 0;
+
+    //Count GPS SVs for saparating GPS from GLONASS and throw others
+
+    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) )
+        {
+            gpsCount++;
+        }
+        else if( (svStatus.sv_list[svNumber-1].prn >= GLONASS_PRN_START) &&
+                 (svStatus.sv_list[svNumber-1].prn <= GLONASS_PRN_END) )
+        {
+            glnCount++;
+        }
+    }
 
     // ------------------
     // ------$GPGSV------
     // ------------------
 
-    if (svStatus.num_svs <= 0)
+    if (gpsCount <= 0)
     {
         // no svs in view, so just send a blank $GPGSV sentence
         strlcpy(sentence, "$GPGSV,1,1,0,", sizeof(sentence));
@@ -619,12 +644,9 @@ void loc_eng_nmea_generate_sv(loc_eng_data_s_type *loc_eng_data_p,
     }
     else
     {
-        int svCount = svStatus.num_svs;
-        int sentenceCount = svCount / 4;
-        if (svStatus.num_svs % 4)
-            sentenceCount++;
-        int sentenceNumber = 1;
-        int svNumber = 1;
+        svNumber = 1;
+        sentenceNumber = 1;
+        sentenceCount = gpsCount/4 + (gpsCount % 4 != 0);
 
         while (sentenceNumber <= sentenceCount)
         {
@@ -632,7 +654,7 @@ void loc_eng_nmea_generate_sv(loc_eng_data_s_type *loc_eng_data_p,
             lengthRemaining = sizeof(sentence);
 
             length = snprintf(pMarker, lengthRemaining, "$GPGSV,%d,%d,%02d",
-                          sentenceCount, sentenceNumber, svCount);
+                          sentenceCount, sentenceNumber, gpsCount);
 
             if (length < 0 || length >= lengthRemaining)
             {
@@ -642,25 +664,93 @@ void loc_eng_nmea_generate_sv(loc_eng_data_s_type *loc_eng_data_p,
             pMarker += length;
             lengthRemaining -= length;
 
-            for (int i=0; (svNumber <= svCount) && (i < 4); i++, svNumber++)
+            for (int i=0; (svNumber <= svCount) && (i < 4);  svNumber++)
             {
-                length = snprintf(pMarker, lengthRemaining,",%02d,%02d,%03d,",
+                if( (svStatus.sv_list[svNumber-1].prn >= GPS_PRN_START) &&
+                    (svStatus.sv_list[svNumber-1].prn <= GPS_PRN_END) )
+                {
+                    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
 
-                if (length < 0 || length >= lengthRemaining)
-                {
-                    LOC_LOGE("NMEA Error in string formatting");
-                    return;
-                }
-                pMarker += length;
-                lengthRemaining -= length;
+                    if (length < 0 || length >= lengthRemaining)
+                    {
+                        LOC_LOGE("NMEA Error in string formatting");
+                        return;
+                    }
+                    pMarker += length;
+                    lengthRemaining -= length;
 
-                if (svStatus.sv_list[svNumber-1].snr > 0)
-                {
-                    length = snprintf(pMarker, lengthRemaining,"%02d",
-                                     (int)(0.5 + svStatus.sv_list[svNumber-1].snr)); //float to int
+                    if (svStatus.sv_list[svNumber-1].snr > 0)
+                    {
+                        length = snprintf(pMarker, lengthRemaining,"%02d",
+                                         (int)(0.5 + svStatus.sv_list[svNumber-1].snr)); //float to int
+
+                        if (length < 0 || length >= lengthRemaining)
+                        {
+                            LOC_LOGE("NMEA Error in string formatting");
+                            return;
+                        }
+                        pMarker += length;
+                        lengthRemaining -= length;
+                    }
+
+                    i++;
+               }
+
+            }
+
+            length = loc_eng_nmea_put_checksum(sentence, sizeof(sentence));
+            loc_eng_nmea_send(sentence, length, loc_eng_data_p);
+            sentenceNumber++;
+
+        }  //while
+
+    } //if
+
+    // ------------------
+    // ------$GLGSV------
+    // ------------------
+
+    if (glnCount <= 0)
+    {
+        // no svs in view, so just send a blank $GLGSV sentence
+        strlcpy(sentence, "$GLGSV,1,1,0,", sizeof(sentence));
+        length = loc_eng_nmea_put_checksum(sentence, sizeof(sentence));
+        loc_eng_nmea_send(sentence, length, loc_eng_data_p);
+    }
+    else
+    {
+        svNumber = 1;
+        sentenceNumber = 1;
+        sentenceCount = glnCount/4 + (glnCount % 4 != 0);
+
+        while (sentenceNumber <= sentenceCount)
+        {
+            pMarker = sentence;
+            lengthRemaining = sizeof(sentence);
+
+            length = snprintf(pMarker, lengthRemaining, "$GLGSV,%d,%d,%02d",
+                          sentenceCount, sentenceNumber, glnCount);
+
+            if (length < 0 || length >= lengthRemaining)
+            {
+                LOC_LOGE("NMEA Error in string formatting");
+                return;
+            }
+            pMarker += length;
+            lengthRemaining -= length;
+
+            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) )      {
+
+                    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
 
                     if (length < 0 || length >= lengthRemaining)
                     {
@@ -669,15 +759,33 @@ 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)
+                    {
+                        length = snprintf(pMarker, lengthRemaining,"%02d",
+                                         (int)(0.5 + svStatus.sv_list[svNumber-1].snr)); //float to int
+
+                        if (length < 0 || length >= lengthRemaining)
+                        {
+                            LOC_LOGE("NMEA Error in string formatting");
+                            return;
+                        }
+                        pMarker += length;
+                        lengthRemaining -= length;
+                    }
+
+                    i++;
+               }
+
             }
 
             length = loc_eng_nmea_put_checksum(sentence, sizeof(sentence));
             loc_eng_nmea_send(sentence, length, loc_eng_data_p);
             sentenceNumber++;
 
-        }
-    }
+        }  //while
+
+    }//if
 
     if (svStatus.used_in_fix_mask == 0)
     {   // No sv used, so there will be no position report, so send
diff --git a/utils/Android.mk b/utils/Android.mk
index 18c7ccc..82c56f6 100644
--- a/utils/Android.mk
+++ b/utils/Android.mk
@@ -1,3 +1,6 @@
+ifeq (, $(filter aarch64 arm64, $(TARGET_ARCH)))
+ifneq ($(BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE),)
+ifneq ($(BUILD_TINY_ANDROID),true)
 #Compile this library only for builds with the latest modem image
 
 LOCAL_PATH := $(call my-dir)
@@ -17,13 +20,17 @@ LOCAL_SRC_FILES += \
     linked_list.c \
     loc_target.cpp \
     loc_timer.c \
-    ../platform_lib_abstractions/elapsed_millis_since_boot.cpp
-
+    ../platform_lib_abstractions/elapsed_millis_since_boot.cpp \
+    loc_misc_utils.cpp
 
 LOCAL_CFLAGS += \
      -fno-short-enums \
      -D_ANDROID_
 
+ifeq ($(TARGET_BUILD_VARIANT),user)
+   LOCAL_CFLAGS += -DTARGET_BUILD_VARIANT_USER
+endif
+
 LOCAL_LDFLAGS += -Wl,--export-dynamic
 
 ## Includes
@@ -41,8 +48,8 @@ LOCAL_COPY_HEADERS:= \
    loc_timer.h \
    ../platform_lib_abstractions/platform_lib_includes.h \
    ../platform_lib_abstractions/platform_lib_time.h \
-   ../platform_lib_abstractions/platform_lib_macros.h
-
+   ../platform_lib_abstractions/platform_lib_macros.h \
+   loc_misc_utils.h
 
 LOCAL_MODULE := libgps.utils
 
@@ -52,3 +59,6 @@ LOCAL_PRELINK_MODULE := false
 
 LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)
 include $(BUILD_SHARED_LIBRARY)
+endif # not BUILD_TINY_ANDROID
+endif # BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE
+endif # not aarch64
diff --git a/utils/loc_cfg.cpp b/utils/loc_cfg.cpp
index 73d1ca4..b8315ee 100644
--- a/utils/loc_cfg.cpp
+++ b/utils/loc_cfg.cpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2011-2013, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2011-2014, 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
@@ -39,6 +39,7 @@
 #include <time.h>
 #include <loc_cfg.h>
 #include <log_util.h>
+#include <loc_misc_utils.h>
 #ifdef USE_GLIB
 #include <glib.h>
 #endif
@@ -57,16 +58,30 @@ static uint8_t TIMESTAMP = 0;
 /* Parameter spec table */
 static loc_param_s_type loc_parameter_table[] =
 {
-  {"DEBUG_LEVEL",                    &DEBUG_LEVEL, NULL,                   'n'},
-  {"TIMESTAMP",                      &TIMESTAMP,   NULL,                   'n'},
+    {"DEBUG_LEVEL",    &DEBUG_LEVEL, NULL,    'n'},
+    {"TIMESTAMP",      &TIMESTAMP,   NULL,    'n'},
 };
 int loc_param_num = sizeof(loc_parameter_table) / sizeof(loc_param_s_type);
 
+typedef struct loc_param_v_type
+{
+    char* param_name;
+    char* param_str_value;
+    int param_int_value;
+    double param_double_value;
+}loc_param_v_type;
+
 /*===========================================================================
-FUNCTION trim_space
+FUNCTION loc_set_config_entry
 
 DESCRIPTION
-   Removes leading and trailing spaces of the string
+   Potentially sets a given configuration table entry based on the passed in
+   configuration value. This is done by using a string comparison of the
+   parameter names and those found in the configuration file.
+
+PARAMETERS:
+   config_entry: configuration entry in the table to possibly set
+   config_value: value to store in the entry if the parameter names match
 
 DEPENDENCIES
    N/A
@@ -77,122 +92,177 @@ RETURN VALUE
 SIDE EFFECTS
    N/A
 ===========================================================================*/
-void trim_space(char *org_string)
+int loc_set_config_entry(loc_param_s_type* config_entry, loc_param_v_type* config_value)
 {
-   char *scan_ptr, *write_ptr;
-   char *first_nonspace = NULL, *last_nonspace = NULL;
-
-   scan_ptr = write_ptr = org_string;
-
-   while (*scan_ptr)
-   {
-      if ( !isspace(*scan_ptr) && first_nonspace == NULL)
-      {
-         first_nonspace = scan_ptr;
-      }
-
-      if (first_nonspace != NULL)
-      {
-         *(write_ptr++) = *scan_ptr;
-         if ( !isspace(*scan_ptr))
-         {
-            last_nonspace = write_ptr;
-         }
-      }
-
-      scan_ptr++;
-   }
-
-   if (last_nonspace) { *last_nonspace = '\0'; }
+    int ret=-1;
+    if(NULL == config_entry || NULL == config_value)
+    {
+        LOC_LOGE("%s: INVALID config entry or parameter", __FUNCTION__);
+        return ret;
+    }
+
+    if (strcmp(config_entry->param_name, config_value->param_name) == 0 &&
+        config_entry->param_ptr)
+    {
+        switch (config_entry->param_type)
+        {
+        case 's':
+            if (strcmp(config_value->param_str_value, "NULL") == 0)
+            {
+                *((char*)config_entry->param_ptr) = '\0';
+            }
+            else {
+                strlcpy((char*) config_entry->param_ptr,
+                        config_value->param_str_value,
+                        LOC_MAX_PARAM_STRING + 1);
+            }
+            /* Log INI values */
+            LOC_LOGD("%s: PARAM %s = %s", __FUNCTION__, config_entry->param_name, (char*)config_entry->param_ptr);
+
+            if(NULL != config_entry->param_set)
+            {
+                *(config_entry->param_set) = 1;
+            }
+            ret = 0;
+            break;
+        case 'n':
+            *((int *)config_entry->param_ptr) = config_value->param_int_value;
+            /* Log INI values */
+            LOC_LOGD("%s: PARAM %s = %d", __FUNCTION__, config_entry->param_name, config_value->param_int_value);
+
+            if(NULL != config_entry->param_set)
+            {
+                *(config_entry->param_set) = 1;
+            }
+            ret = 0;
+            break;
+        case 'f':
+            *((double *)config_entry->param_ptr) = config_value->param_double_value;
+            /* Log INI values */
+            LOC_LOGD("%s: PARAM %s = %f", __FUNCTION__, config_entry->param_name, config_value->param_double_value);
+
+            if(NULL != config_entry->param_set)
+            {
+                *(config_entry->param_set) = 1;
+            }
+            ret = 0;
+            break;
+        default:
+            LOC_LOGE("%s: PARAM %s parameter type must be n, f, or s", __FUNCTION__, config_entry->param_name);
+        }
+    }
+    return ret;
 }
 
-typedef struct loc_param_v_type
-{
-   char* param_name;
-
-   char* param_str_value;
-   int param_int_value;
-   double param_double_value;
-}loc_param_v_type;
-
 /*===========================================================================
-FUNCTION loc_set_config_entry
+FUNCTION loc_read_conf_r (repetitive)
 
 DESCRIPTION
-   Potentially sets a given configuration table entry based on the passed in
-   configuration value. This is done by using a string comparison of the
-   parameter names and those found in the configuration file.
+   Reads the specified configuration file and sets defined values based on
+   the passed in configuration table. This table maps strings to values to
+   set along with the type of each of these values.
+   The difference between this and loc_read_conf is that this function returns
+   the file pointer position at the end of filling a config table. Also, it
+   reads a fixed number of parameters at a time which is equal to the length
+   of the configuration table. This functionality enables the caller to
+   repeatedly call the function to read data from the same file.
 
 PARAMETERS:
-   config_entry: configuration entry in the table to possibly set
-   config_value: value to store in the entry if the parameter names match
+   conf_fp : file pointer
+   config_table: table definition of strings to places to store information
+   table_length: length of the configuration table
 
 DEPENDENCIES
    N/A
 
 RETURN VALUE
-   None
+   0: Table filled successfully
+   1: No more parameters to read
+  -1: Error filling table
 
 SIDE EFFECTS
    N/A
 ===========================================================================*/
-void loc_set_config_entry(loc_param_s_type* config_entry, loc_param_v_type* config_value)
+int loc_read_conf_r(FILE *conf_fp, loc_param_s_type* config_table, uint32_t table_length)
 {
-   if(NULL == config_entry || NULL == config_value)
-   {
-      LOC_LOGE("%s: INVALID config entry or parameter", __FUNCTION__);
-      return;
-   }
-
-   if (strcmp(config_entry->param_name, config_value->param_name) == 0 &&
-               config_entry->param_ptr)
-   {
-      switch (config_entry->param_type)
-      {
-      case 's':
-         if (strcmp(config_value->param_str_value, "NULL") == 0)
-         {
-            *((char*)config_entry->param_ptr) = '\0';
-         }
-         else {
-            strlcpy((char*) config_entry->param_ptr,
-                  config_value->param_str_value,
-                  LOC_MAX_PARAM_STRING + 1);
-         }
-         /* Log INI values */
-         LOC_LOGD("%s: PARAM %s = %s", __FUNCTION__, config_entry->param_name, (char*)config_entry->param_ptr);
-
-         if(NULL != config_entry->param_set)
-         {
-            *(config_entry->param_set) = 1;
-         }
-         break;
-      case 'n':
-         *((int *)config_entry->param_ptr) = config_value->param_int_value;
-         /* Log INI values */
-         LOC_LOGD("%s: PARAM %s = %d", __FUNCTION__, config_entry->param_name, config_value->param_int_value);
-
-         if(NULL != config_entry->param_set)
-         {
-            *(config_entry->param_set) = 1;
-         }
-         break;
-      case 'f':
-         *((double *)config_entry->param_ptr) = config_value->param_double_value;
-         /* Log INI values */
-         LOC_LOGD("%s: PARAM %s = %f", __FUNCTION__, config_entry->param_name, config_value->param_double_value);
-
-         if(NULL != config_entry->param_set)
-         {
-            *(config_entry->param_set) = 1;
-         }
-         break;
-      default:
-         LOC_LOGE("%s: PARAM %s parameter type must be n, f, or s", __FUNCTION__, config_entry->param_name);
-      }
-   }
+    char input_buf[LOC_MAX_PARAM_LINE];  /* declare a char array */
+    char *lasts;
+    loc_param_v_type config_value;
+    uint32_t i;
+    int ret=0;
+
+    unsigned int num_params=table_length;
+    if(conf_fp == NULL) {
+        LOC_LOGE("%s:%d]: ERROR: File pointer is NULL\n", __func__, __LINE__);
+        ret = -1;
+        goto err;
+    }
+
+    /* Clear all validity bits */
+    for(i = 0; NULL != config_table && i < table_length; i++)
+    {
+        if(NULL != config_table[i].param_set)
+        {
+            *(config_table[i].param_set) = 0;
+        }
+    }
+    LOC_LOGD("%s:%d]: num_params: %d\n", __func__, __LINE__, num_params);
+    while(num_params)
+    {
+        if(!fgets(input_buf, LOC_MAX_PARAM_LINE, conf_fp)) {
+            LOC_LOGD("%s:%d]: fgets returned NULL\n", __func__, __LINE__);
+            break;
+        }
+
+        memset(&config_value, 0, sizeof(config_value));
+
+        /* Separate variable and value */
+        config_value.param_name = strtok_r(input_buf, "=", &lasts);
+        /* skip lines that do not contain "=" */
+        if (config_value.param_name == NULL) continue;
+        config_value.param_str_value = strtok_r(NULL, "=", &lasts);
+        /* skip lines that do not contain two operands */
+        if (config_value.param_str_value == NULL) continue;
+
+        /* Trim leading and trailing spaces */
+        loc_util_trim_space(config_value.param_name);
+        loc_util_trim_space(config_value.param_str_value);
+
+        /* Parse numerical value */
+        if ((strlen(config_value.param_str_value) >=3) &&
+            (config_value.param_str_value[0] == '0') &&
+            (tolower(config_value.param_str_value[1]) == 'x'))
+        {
+            /* hex */
+            config_value.param_int_value = (int) strtol(&config_value.param_str_value[2],
+                                                        (char**) NULL, 16);
+        }
+        else {
+            config_value.param_double_value = (double) atof(config_value.param_str_value); /* float */
+            config_value.param_int_value = atoi(config_value.param_str_value); /* dec */
+        }
+
+        for(i = 0; NULL != config_table && i < table_length; i++)
+        {
+            if(!loc_set_config_entry(&config_table[i], &config_value)) {
+                num_params--;
+            }
+        }
+    }
+
+err:
+    return ret;
 }
 
+typedef struct loc_param_v_type
+{
+   char* param_name;
+
+   char* param_str_value;
+   int param_int_value;
+   double param_double_value;
+}loc_param_v_type;
+
 /*===========================================================================
 FUNCTION loc_read_conf
 
@@ -215,72 +285,25 @@ RETURN VALUE
 SIDE EFFECTS
    N/A
 ===========================================================================*/
-void loc_read_conf(const char* conf_file_name, loc_param_s_type* config_table, uint32_t table_length)
+void loc_read_conf(const char* conf_file_name, loc_param_s_type* config_table,
+                   uint32_t table_length)
 {
-   FILE *gps_conf_fp = NULL;
-   char input_buf[LOC_MAX_PARAM_LINE];  /* declare a char array */
-   char *lasts;
-   loc_param_v_type config_value;
-   uint32_t i;
-
-   if((gps_conf_fp = fopen(conf_file_name, "r")) != NULL)
-   {
-      LOC_LOGD("%s: using %s", __FUNCTION__, conf_file_name);
-   }
-   else
-   {
-      LOC_LOGW("%s: no %s file found", __FUNCTION__, conf_file_name);
-      loc_logger_init(DEBUG_LEVEL, TIMESTAMP);
-      return; /* no parameter file */
-   }
-
-   /* Clear all validity bits */
-   for(i = 0; NULL != config_table && i < table_length; i++)
-   {
-      if(NULL != config_table[i].param_set)
-      {
-         *(config_table[i].param_set) = 0;
-      }
-   }
-
-   while(fgets(input_buf, LOC_MAX_PARAM_LINE, gps_conf_fp) != NULL)
-   {
-      memset(&config_value, 0, sizeof(config_value));
-
-      /* Separate variable and value */
-      config_value.param_name = strtok_r(input_buf, "=", &lasts);
-      if (config_value.param_name == NULL) continue;       /* skip lines that do not contain "=" */
-      config_value.param_str_value = strtok_r(NULL, "=", &lasts);
-      if (config_value.param_str_value == NULL) continue;  /* skip lines that do not contain two operands */
-
-      /* Trim leading and trailing spaces */
-      trim_space(config_value.param_name);
-      trim_space(config_value.param_str_value);
-
-      /* Parse numerical value */
-      if (config_value.param_str_value[0] == '0' && tolower(config_value.param_str_value[1]) == 'x')
-      {
-         /* hex */
-         config_value.param_int_value = (int) strtol(&config_value.param_str_value[2], (char**) NULL, 16);
-      }
-      else {
-         config_value.param_double_value = (double) atof(config_value.param_str_value); /* float */
-         config_value.param_int_value = atoi(config_value.param_str_value); /* dec */
-      }
-
-      for(i = 0; NULL != config_table && i < table_length; i++)
-      {
-         loc_set_config_entry(&config_table[i], &config_value);
-      }
-
-      for(i = 0; i < loc_param_num; i++)
-      {
-         loc_set_config_entry(&loc_parameter_table[i], &config_value);
-      }
-   }
-
-   fclose(gps_conf_fp);
-
-   /* Initialize logging mechanism with parsed data */
-   loc_logger_init(DEBUG_LEVEL, TIMESTAMP);
+    FILE *gps_conf_fp = NULL;
+    char input_buf[LOC_MAX_PARAM_LINE];  /* declare a char array */
+    char *lasts;
+    loc_param_v_type config_value;
+    uint32_t i;
+
+    if((gps_conf_fp = fopen(conf_file_name, "r")) != NULL)
+    {
+        LOC_LOGD("%s: using %s", __FUNCTION__, conf_file_name);
+        if(table_length && config_table) {
+            loc_read_conf_r(gps_conf_fp, config_table, table_length);
+            rewind(gps_conf_fp);
+        }
+        loc_read_conf_r(gps_conf_fp, loc_parameter_table, loc_param_num);
+        fclose(gps_conf_fp);
+    }
+    /* Initialize logging mechanism with parsed data */
+    loc_logger_init(DEBUG_LEVEL, TIMESTAMP);
 }
diff --git a/utils/loc_cfg.h b/utils/loc_cfg.h
index df83338..268f4c2 100644
--- a/utils/loc_cfg.h
+++ b/utils/loc_cfg.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2011-2013, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2011-2014, 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
@@ -30,6 +30,7 @@
 #ifndef LOC_CFG_H
 #define LOC_CFG_H
 
+#include <stdio.h>
 #include <stdint.h>
 
 #define LOC_MAX_PARAM_NAME                 48
@@ -75,7 +76,7 @@ extern "C" {
 extern void loc_read_conf(const char* conf_file_name,
                           loc_param_s_type* config_table,
                           uint32_t table_length);
-
+extern int loc_read_conf_r(FILE *conf_fp, loc_param_s_type* config_table, uint32_t table_length);
 #ifdef __cplusplus
 }
 #endif
diff --git a/utils/loc_log.cpp b/utils/loc_log.cpp
index f755d70..392966e 100644
--- a/utils/loc_log.cpp
+++ b/utils/loc_log.cpp
@@ -112,7 +112,7 @@ loc_name_val_s_type target_name[] =
     NAME_VAL(GNSS_MSM),
     NAME_VAL(GNSS_GSS),
     NAME_VAL(GNSS_MDM),
-    NAME_VAL(GNSS_GRIFFON),
+    NAME_VAL(GNSS_QCA1530),
     NAME_VAL(GNSS_UNKNOWN)
 };
 
@@ -134,18 +134,18 @@ RETURN VALUE
 const char *loc_get_target_name(unsigned int target)
 {
     int index = 0;
-    char ret[BUFFER_SIZE];
+    static char ret[BUFFER_SIZE];
 
     index =  getTargetGnssType(target);
     if( index >= target_name_num || index < 0)
         index = target_name_num - 1;
 
     if( (target & HAS_SSC) == HAS_SSC ) {
-        sprintf(ret, " %s with SSC",
+        snprintf(ret, sizeof(ret), " %s with SSC",
            loc_get_name_from_val(target_name, target_name_num, (long)index) );
     }
     else {
-       sprintf(ret, " %s  without SSC",
+       snprintf(ret, sizeof(ret), " %s  without SSC",
            loc_get_name_from_val(target_name, target_name_num, (long)index) );
     }
     return ret;
@@ -200,6 +200,12 @@ SIDE EFFECTS
 void loc_logger_init(unsigned long debug, unsigned long timestamp)
 {
    loc_logger.DEBUG_LEVEL = debug;
+#ifdef TARGET_BUILD_VARIANT_USER
+   // force user builds to 2 or less
+   if (loc_logger.DEBUG_LEVEL > 2) {
+       loc_logger.DEBUG_LEVEL = 2;
+   }
+#endif
    loc_logger.TIMESTAMP   = timestamp;
 }
 
diff --git a/utils/loc_misc_utils.cpp b/utils/loc_misc_utils.cpp
new file mode 100644
index 0000000..7e96313
--- /dev/null
+++ b/utils/loc_misc_utils.cpp
@@ -0,0 +1,114 @@
+/* Copyright (c) 2014, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *     * Neither the name of The Linux Foundation, nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+#include <stdio.h>
+#include <string.h>
+#include <log_util.h>
+#include <loc_misc_utils.h>
+#include <ctype.h>
+
+#define LOG_NDDEBUG 0
+#define LOG_TAG "LocSvc_misc_utils"
+
+int loc_util_split_string(char *raw_string, char **split_strings_ptr,
+                          int max_num_substrings, char delimiter)
+{
+    int raw_string_index=0;
+    int num_split_strings=0;
+    unsigned char end_string=0;
+    int raw_string_length=0;
+
+    if(!raw_string || !split_strings_ptr) {
+        LOC_LOGE("%s:%d]: NULL parameters", __func__, __LINE__);
+        num_split_strings = -1;
+        goto err;
+    }
+    LOC_LOGD("%s:%d]: raw string: %s\n", __func__, __LINE__, raw_string);
+    raw_string_length = strlen(raw_string) + 1;
+    split_strings_ptr[num_split_strings] = &raw_string[raw_string_index];
+    for(raw_string_index=0; raw_string_index < raw_string_length; raw_string_index++) {
+        if(raw_string[raw_string_index] == '\0')
+            end_string=1;
+        if((raw_string[raw_string_index] == delimiter) || end_string) {
+            raw_string[raw_string_index] = '\0';
+            LOC_LOGD("%s:%d]: split string: %s\n",
+                     __func__, __LINE__, split_strings_ptr[num_split_strings]);
+            num_split_strings++;
+            if(((raw_string_index + 1) < raw_string_length) &&
+               (num_split_strings < max_num_substrings)) {
+                split_strings_ptr[num_split_strings] = &raw_string[raw_string_index+1];
+            }
+            else {
+                break;
+            }
+        }
+        if(end_string)
+            break;
+    }
+err:
+    LOC_LOGD("%s:%d]: num_split_strings: %d\n", __func__, __LINE__, num_split_strings);
+    return num_split_strings;
+}
+
+void loc_util_trim_space(char *org_string)
+{
+    char *scan_ptr, *write_ptr;
+    char *first_nonspace = NULL, *last_nonspace = NULL;
+
+    if(org_string == NULL) {
+        LOC_LOGE("%s:%d]: NULL parameter", __func__, __LINE__);
+        goto err;
+    }
+
+    scan_ptr = write_ptr = org_string;
+
+    while (*scan_ptr) {
+        //Find the first non-space character
+        if ( !isspace(*scan_ptr) && first_nonspace == NULL) {
+            first_nonspace = scan_ptr;
+        }
+        //Once the first non-space character is found in the
+        //above check, keep shifting the characters to the left
+        //to replace the spaces
+        if (first_nonspace != NULL) {
+            *(write_ptr++) = *scan_ptr;
+            //Keep track of which was the last non-space character
+            //encountered
+            //last_nonspace will not be updated in the case where
+            //the string ends with spaces
+            if ( !isspace(*scan_ptr)) {
+                last_nonspace = write_ptr;
+            }
+        }
+        scan_ptr++;
+    }
+    //Add NULL terminator after the last non-space character
+    if (last_nonspace) { *last_nonspace = '\0'; }
+err:
+    return;
+}
diff --git a/utils/loc_misc_utils.h b/utils/loc_misc_utils.h
new file mode 100644
index 0000000..7d66d84
--- /dev/null
+++ b/utils/loc_misc_utils.h
@@ -0,0 +1,99 @@
+/* Copyright (c) 2014, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *     * Neither the name of The Linux Foundation, nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+#ifndef _LOC_MISC_UTILS_H_
+#define _LOC_MISC_UTILS_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*===========================================================================
+FUNCTION loc_split_string
+
+DESCRIPTION:
+    This function is used to split a delimiter separated string into
+    sub-strings. This function does not allocate new memory to store the split
+    strings. Instead, it places '\0' in places of delimiters and assings the
+    starting address of the substring within the raw string as the string address
+    The input raw_string no longer remains to be a collection of sub-strings
+    after this function is executed.
+    Please make a copy of the input string before calling this function if
+    necessary
+
+PARAMETERS:
+    char *raw_string: is the original string with delimiter separated substrings
+    char **split_strings_ptr: is the arraw of pointers which will hold the addresses
+                              of individual substrings
+    int max_num_substrings: is the maximum number of substrings that are expected
+                            by the caller. The array of pointers in the above parameter
+                            is usually this long
+    char delimiter: is the delimiter that separates the substrings. Examples: ' ', ';'
+
+DEPENDENCIES
+    N/A
+
+RETURN VALUE
+    int Number of split strings
+
+SIDE EFFECTS
+    The input raw_string no longer remains a delimiter separated single string.
+
+EXAMPLE
+    delimiter = ' ' //space
+    raw_string = "hello new user" //delimiter is space ' '
+    addresses  =  0123456789abcd
+    split_strings_ptr[0] = &raw_string[0]; //split_strings_ptr[0] contains "hello"
+    split_strings_ptr[1] = &raw_string[6]; //split_strings_ptr[1] contains "new"
+    split_strings_ptr[2] = &raw_string[a]; //split_strings_ptr[2] contains "user"
+
+===========================================================================*/
+int loc_util_split_string(char *raw_string, char **split_strings_ptr, int max_num_substrings,
+                     char delimiter);
+
+/*===========================================================================
+FUNCTION trim_space
+
+DESCRIPTION
+   Removes leading and trailing spaces of the string
+
+DEPENDENCIES
+   N/A
+
+RETURN VALUE
+   None
+
+SIDE EFFECTS
+   N/A
+===========================================================================*/
+void loc_util_trim_space(char *org_string);
+#ifdef __cplusplus
+}
+#endif
+
+#endif //_LOC_MISC_UTILS_H_
diff --git a/utils/loc_target.cpp b/utils/loc_target.cpp
index 26df4cb..d46747a 100644
--- a/utils/loc_target.cpp
+++ b/utils/loc_target.cpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2012, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2012-2014, 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
@@ -56,8 +56,14 @@
 #define LENGTH(s) (sizeof(s) - 1)
 #define GPS_CHECK_NO_ERROR 0
 #define GPS_CHECK_NO_GPS_HW 1
+/* When system server is started, it uses 20 seconds as ActivityManager
+ * timeout. After that it sends SIGSTOP signal to process.
+ */
+#define QCA1530_DETECT_TIMEOUT 15
+#define QCA1530_DETECT_PRESENT "yes"
+#define QCA1530_DETECT_PROGRESS "detect"
 
-static int gss_fd = 0;
+static unsigned int gTarget = (unsigned int)-1;
 
 static int read_a_line(const char * file_path, char * line, int line_size)
 {
@@ -81,29 +87,132 @@ static int read_a_line(const char * file_path, char * line, int line_size)
     return result;
 }
 
-unsigned int get_target(void)
+/*!
+ * \brief Checks if QCA1530 is avalable.
+ *
+ * Function verifies if qca1530 SoC is configured on the device. The test is
+ * based on property value. For 1530 scenario, the value shall be one of the
+ * following: "yes", "no", "detect". All other values are treated equally to
+ * "no". When the value is "detect" the system waits for SoC detection to
+ * finish before returning result.
+ *
+ * \retval true - QCA1530 is available.
+ * \retval false - QCA1530 is not available.
+ */
+static bool is_qca1530(void)
+{
+    static const char qca1530_property_name[] = "sys.qca1530";
+    bool res = false;
+    int ret, i;
+    char buf[PROPERTY_VALUE_MAX];
+
+    memset(buf, 0, sizeof(buf));
+
+    for (i = 0; i < QCA1530_DETECT_TIMEOUT; ++i)
+    {
+        ret = property_get(qca1530_property_name, buf, NULL);
+        if (ret < 0)
+        {
+            LOC_LOGV( "qca1530: property %s is not accessible, ret=%d",
+                  qca1530_property_name,
+                  ret);
+
+            break;
+        }
+
+        LOC_LOGV( "qca1530: property %s is set to %s",
+                  qca1530_property_name,
+                  buf);
+
+        if (!memcmp(buf, QCA1530_DETECT_PRESENT,
+                    sizeof(QCA1530_DETECT_PRESENT)))
+        {
+            res = true;
+            break;
+        }
+        if (!memcmp(buf, QCA1530_DETECT_PROGRESS,
+                    sizeof(QCA1530_DETECT_PROGRESS)))
+        {
+            LOC_LOGV("qca1530: SoC detection is in progress.");
+            sleep(1);
+            continue;
+        }
+        break;
+    }
+
+    LOC_LOGD("qca1530: detected=%s", res ? "true" : "false");
+    return res;
+}
+
+/*The character array passed to this function should have length
+  of atleast PROPERTY_VALUE_MAX*/
+void loc_get_target_baseband(char *baseband, int array_length)
+{
+    if(baseband && (array_length >= PROPERTY_VALUE_MAX)) {
+        property_get("ro.baseband", baseband, "");
+        LOC_LOGD("%s:%d]: Baseband: %s\n", __func__, __LINE__, baseband);
+    }
+    else {
+        LOC_LOGE("%s:%d]: NULL parameter or array length less than PROPERTY_VALUE_MAX\n",
+                 __func__, __LINE__);
+    }
+}
+
+/*The character array passed to this function should have length
+  of atleast PROPERTY_VALUE_MAX*/
+void loc_get_platform_name(char *platform_name, int array_length)
+{
+    if(platform_name && (array_length >= PROPERTY_VALUE_MAX)) {
+        property_get("ro.board.platform", platform_name, "");
+        LOC_LOGD("%s:%d]: Target name: %s\n", __func__, __LINE__, platform_name);
+    }
+    else {
+        LOC_LOGE("%s:%d]: Null parameter or array length less than PROPERTY_VALUE_MAX\n",
+                 __func__, __LINE__);
+    }
+}
+
+unsigned int loc_get_target(void)
 {
-    unsigned int target = TARGET_DEFAULT;
+    if (gTarget != (unsigned int)-1)
+        return gTarget;
 
-    char hw_platform[]      = "/sys/devices/system/soc/soc0/hw_platform";
-    char id[]               = "/sys/devices/system/soc/soc0/id";
-    char mdm[]              = "/dev/mdm"; // No such file or directory
+    static const char hw_platform[]      = "/sys/devices/soc0/hw_platform";
+    static const char id[]               = "/sys/devices/soc0/soc_id";
+    static const char hw_platform_dep[]  =
+        "/sys/devices/system/soc/soc0/hw_platform";
+    static const char id_dep[]           = "/sys/devices/system/soc/soc0/id";
+    static const char mdm[]              = "/dev/mdm"; // No such file or directory
 
     char rd_hw_platform[LINE_LEN];
     char rd_id[LINE_LEN];
     char rd_mdm[LINE_LEN];
     char baseband[LINE_LEN];
 
-    property_get("ro.baseband", baseband, "");
-    read_a_line(hw_platform, rd_hw_platform, LINE_LEN);
-    read_a_line( id, rd_id, LINE_LEN);
+    if (is_qca1530()) {
+        gTarget = TARGET_QCA1530;
+        goto detected;
+    }
+
+    loc_get_target_baseband(baseband, sizeof(baseband));
+
+    if (!access(hw_platform, F_OK)) {
+        read_a_line(hw_platform, rd_hw_platform, LINE_LEN);
+    } else {
+        read_a_line(hw_platform_dep, rd_hw_platform, LINE_LEN);
+    }
+    if (!access(id, F_OK)) {
+        read_a_line(id, rd_id, LINE_LEN);
+    } else {
+        read_a_line(id_dep, rd_id, LINE_LEN);
+    }
 
     if( !memcmp(baseband, STR_APQ, LENGTH(STR_APQ)) ){
         if( !memcmp(rd_id, MPQ8064_ID_1, LENGTH(MPQ8064_ID_1))
             && IS_STR_END(rd_id[LENGTH(MPQ8064_ID_1)]) )
-            target = TARGET_MPQ;
+            gTarget = TARGET_MPQ;
         else
-            target = TARGET_APQ_SA;
+            gTarget = TARGET_APQ_SA;
     }
     else {
         if( (!memcmp(rd_hw_platform, STR_LIQUID, LENGTH(STR_LIQUID))
@@ -114,13 +223,18 @@ unsigned int get_target(void)
              && IS_STR_END(rd_hw_platform[LENGTH(STR_MTP)]))) {
 
             if (!read_a_line( mdm, rd_mdm, LINE_LEN))
-                target = TARGET_MDM;
+                gTarget = TARGET_MDM;
         }
         else if( (!memcmp(rd_id, MSM8930_ID_1, LENGTH(MSM8930_ID_1))
                    && IS_STR_END(rd_id[LENGTH(MSM8930_ID_1)])) ||
                   (!memcmp(rd_id, MSM8930_ID_2, LENGTH(MSM8930_ID_2))
                    && IS_STR_END(rd_id[LENGTH(MSM8930_ID_2)])) )
-             target = TARGET_MSM_NO_SSC;
+             gTarget = TARGET_MSM_NO_SSC;
+        else
+             gTarget = TARGET_UNKNOWN;
     }
-    return target;
+
+detected:
+    LOC_LOGD("HAL: %s returned %d", __FUNCTION__, gTarget);
+    return gTarget;
 }
diff --git a/utils/loc_target.h b/utils/loc_target.h
index 12cff1d..9aa525f 100644
--- a/utils/loc_target.h
+++ b/utils/loc_target.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2012, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2012-2014, 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
@@ -34,6 +34,8 @@
 #define TARGET_APQ_SA        TARGET_SET(GNSS_GSS, NO_SSC)
 #define TARGET_MPQ           TARGET_SET(GNSS_NONE,NO_SSC)
 #define TARGET_MSM_NO_SSC    TARGET_SET(GNSS_MSM, NO_SSC)
+#define TARGET_QCA1530       TARGET_SET(GNSS_QCA1530, NO_SSC)
+#define TARGET_UNKNOWN       TARGET_SET(GNSS_UNKNOWN, NO_SSC)
 #define getTargetGnssType(target)  (target>>1)
 
 #ifdef __cplusplus
@@ -41,14 +43,23 @@ extern "C"
 {
 #endif
 
-unsigned int get_target(void);
+unsigned int loc_get_target(void);
 
+/*The character array passed to this function should have length
+  of atleast PROPERTY_VALUE_MAX*/
+void loc_get_target_baseband(char *baseband, int array_length);
+/*The character array passed to this function should have length
+  of atleast PROPERTY_VALUE_MAX*/
+void loc_get_platform_name(char *platform_name, int array_length);
+
+/* Please remember to update 'target_name' in loc_log.cpp,
+   if do any changes to this enum. */
 typedef enum {
     GNSS_NONE = 0,
     GNSS_MSM,
     GNSS_GSS,
     GNSS_MDM,
-    GNSS_GRIFFON,
+    GNSS_QCA1530,
     GNSS_UNKNOWN
 }GNSS_TARGET;
 
diff --git a/utils/loc_timer.c b/utils/loc_timer.c
index 13f7786..1e4008e 100644
--- a/utils/loc_timer.c
+++ b/utils/loc_timer.c
@@ -34,124 +34,153 @@
 #include<time.h>
 #include<errno.h>
 
-#define MAX_DELAY_RETRIES 3
+enum timer_state {
+    READY = 100,
+    WAITING,
+    DONE,
+    ABORT
+};
 
 typedef struct {
     loc_timer_callback callback_func;
     void *user_data;
     unsigned int time_msec;
+    pthread_cond_t timer_cond;
+    pthread_mutex_t timer_mutex;
+    enum timer_state state;
 }timer_data;
 
 static void *timer_thread(void *thread_data)
 {
-    int ret;
-    unsigned char retries=0;
+    int ret = -ETIMEDOUT;
     struct timespec ts;
     struct timeval tv;
-    timer_data t;
-    t.callback_func = ((timer_data *)thread_data)->callback_func;
-    t.user_data = ((timer_data *)thread_data)->user_data;
-    t.time_msec = ((timer_data *)thread_data)->time_msec;
-    pthread_cond_t timer_cond;
-    pthread_mutex_t timer_mutex;
+    timer_data* t = (timer_data*)thread_data;
 
-    LOC_LOGD("%s:%d]: Enter. Delay = %d\n", __func__, __LINE__, t.time_msec);
-    //Copied over all info into local variable. Do not need allocated struct
-    free(thread_data);
+    LOC_LOGD("%s:%d]: Enter. Delay = %d\n", __func__, __LINE__, t->time_msec);
 
-    if(pthread_cond_init(&timer_cond, NULL)) {
-        LOC_LOGE("%s:%d]: Pthread cond init failed\n", __func__, __LINE__);
-        ret = -1;
-        goto err;
+    gettimeofday(&tv, NULL);
+    clock_gettime(CLOCK_REALTIME, &ts);
+    if(t->time_msec >= 1000) {
+        ts.tv_sec += t->time_msec/1000;
+        t->time_msec = t->time_msec % 1000;
     }
-    if(pthread_mutex_init(&timer_mutex, NULL)) {
-        LOC_LOGE("%s:%d]: Pthread mutex init failed\n", __func__, __LINE__);
-        ret = -1;
-        goto mutex_err;
+    if(t->time_msec)
+        ts.tv_nsec += t->time_msec * 1000000;
+    if(ts.tv_nsec > 999999999) {
+        LOC_LOGD("%s:%d]: Large nanosecs\n", __func__, __LINE__);
+        ts.tv_sec += 1;
+        ts.tv_nsec -= 1000000000;
     }
-    while(retries < MAX_DELAY_RETRIES) {
-        gettimeofday(&tv, NULL);
-        clock_gettime(CLOCK_REALTIME, &ts);
-        if(t.time_msec >= 1000) {
-            ts.tv_sec += t.time_msec/1000;
-            t.time_msec = t.time_msec % 1000;
-        }
-        if(t.time_msec)
-            ts.tv_nsec += t.time_msec * 1000000;
-        if(ts.tv_nsec > 999999999) {
-            LOC_LOGD("%s:%d]: Large nanosecs\n", __func__, __LINE__);
-            ts.tv_sec += 1;
-            ts.tv_nsec -= 1000000000;
-        }
-        LOC_LOGD("%s:%d]: ts.tv_sec:%d; ts.tv_nsec:%d\n",
-                 __func__, __LINE__, (int)ts.tv_sec, (int)ts.tv_nsec);
-        LOC_LOGD("%s:%d]: Current time: %d sec; %d nsec\n",
-                 __func__, __LINE__, (int)tv.tv_sec, (int)tv.tv_usec*1000);
-        pthread_mutex_lock(&(timer_mutex));
-        ret = pthread_cond_timedwait(&timer_cond, &timer_mutex, &ts);
-        pthread_mutex_unlock(&(timer_mutex));
-        if(ret != ETIMEDOUT) {
-            LOC_LOGE("%s:%d]: Call to pthread timedwait failed; ret=%d\n",
-                     __func__, __LINE__,ret);
-            ret = -1;
-            retries++;
-        }
-        else {
-            ret = 0;
-            break;
-        }
+    LOC_LOGD("%s:%d]: ts.tv_sec:%d; ts.tv_nsec:%d\n"
+             "\t Current time: %d sec; %d nsec",
+             __func__, __LINE__, (int)ts.tv_sec, (int)ts.tv_nsec,
+             (int)tv.tv_sec, (int)tv.tv_usec*1000);
+
+    pthread_mutex_lock(&(t->timer_mutex));
+    if (READY == t->state) {
+        t->state = WAITING;
+        ret = pthread_cond_timedwait(&t->timer_cond, &t->timer_mutex, &ts);
+        t->state = DONE;
     }
+    pthread_mutex_unlock(&(t->timer_mutex));
 
-    pthread_mutex_destroy(&timer_mutex);
-mutex_err:
-    pthread_cond_destroy(&timer_cond);
-err:
-    if(!ret)
-        t.callback_func(t.user_data, ret);
+    switch (ret) {
+    case ETIMEDOUT:
+        LOC_LOGV("%s:%d]: loc_timer timed out",  __func__, __LINE__);
+        break;
+    case 0:
+        LOC_LOGV("%s:%d]: loc_timer stopped",  __func__, __LINE__);
+        break;
+    case -ETIMEDOUT:
+        LOC_LOGV("%s:%d]: loc_timer cancelled",  __func__, __LINE__);
+        break;
+    default:
+        LOC_LOGE("%s:%d]: Call to pthread timedwait failed; ret=%d\n",
+                 __func__, __LINE__, ret);
+        break;
+    }
+
+    pthread_mutex_destroy(&t->timer_mutex);
+    pthread_cond_destroy(&t->timer_cond);
+
+    if(ETIMEDOUT == ret)
+        t->callback_func(t->user_data, ret);
+
+    free(t);
     LOC_LOGD("%s:%d]: Exit\n", __func__, __LINE__);
     return NULL;
 }
 
-int loc_timer_start(unsigned int msec, loc_timer_callback cb_func,
-                    void* caller_data)
+void* loc_timer_start(unsigned int msec, loc_timer_callback cb_func,
+                      void* caller_data)
 {
-    int ret=0;
     timer_data *t=NULL;
     pthread_attr_t tattr;
     pthread_t id;
     LOC_LOGD("%s:%d]: Enter\n", __func__, __LINE__);
     if(cb_func == NULL || msec == 0) {
         LOC_LOGE("%s:%d]: Error: Wrong parameters\n", __func__, __LINE__);
-        ret = -1;
-        goto err;
+        goto _err;
     }
     t = (timer_data *)calloc(1, sizeof(timer_data));
     if(t == NULL) {
         LOC_LOGE("%s:%d]: Could not allocate memory. Failing.\n",
                  __func__, __LINE__);
-        ret = -1;
-        goto err;
+        goto _err;
+    }
+
+    if(pthread_cond_init(&(t->timer_cond), NULL)) {
+        LOC_LOGE("%s:%d]: Pthread cond init failed\n", __func__, __LINE__);
+        goto t_err;
+    }
+    if(pthread_mutex_init(&(t->timer_mutex), NULL)) {
+        LOC_LOGE("%s:%d]: Pthread mutex init failed\n", __func__, __LINE__);
+        goto cond_err;
     }
 
     t->callback_func = cb_func;
     t->user_data = caller_data;
     t->time_msec = msec;
+    t->state = READY;
 
-    pthread_attr_init(&tattr);
+    if (pthread_attr_init(&tattr)) {
+        LOC_LOGE("%s:%d]: Pthread mutex init failed\n", __func__, __LINE__);
+        goto mutex_err;
+    }
     pthread_attr_setdetachstate(&tattr, PTHREAD_CREATE_DETACHED);
+
     if(pthread_create(&(id), &tattr, timer_thread, (void *)t)) {
         LOC_LOGE("%s:%d]: Could not create thread\n", __func__, __LINE__);
-        ret = -1;
         goto attr_err;
     }
-    else {
-        LOC_LOGD("%s:%d]: Created thread with id: %d\n",
-                 __func__, __LINE__, (int)id);
-    }
+
+    LOC_LOGD("%s:%d]: Created thread with id: %d\n",
+             __func__, __LINE__, (int)id);
+    goto _err;
 
 attr_err:
     pthread_attr_destroy(&tattr);
-err:
+mutex_err:
+    pthread_mutex_destroy(&t->timer_mutex);
+cond_err:
+    pthread_cond_destroy(&t->timer_cond);
+t_err:
+    free(t);
+_err:
     LOC_LOGD("%s:%d]: Exit\n", __func__, __LINE__);
-    return ret;
+    return t;
+}
+
+void loc_timer_stop(void* handle) {
+    timer_data* t = (timer_data*)handle;
+
+    if (NULL != t && (READY == t->state || WAITING == t->state)) {
+        pthread_mutex_lock(&(t->timer_mutex));
+        if (READY == t->state || WAITING == t->state) {
+            pthread_cond_signal(&t->timer_cond);
+            t->state = ABORT;
+        }
+        pthread_mutex_unlock(&(t->timer_mutex));
+    }
 }
diff --git a/utils/loc_timer.h b/utils/loc_timer.h
index 213da20..0034d27 100644
--- a/utils/loc_timer.h
+++ b/utils/loc_timer.h
@@ -43,10 +43,19 @@ extern "C" {
 */
 typedef void(*loc_timer_callback)(void *user_data, int result);
 
-//int loc_timer_start(loc_timer_client_data *p_thread);
-int loc_timer_start(unsigned int delay_msec,
-                    loc_timer_callback,
-                    void* user_data);
+
+/*
+  Returns the handle, which can be used to stop the timer
+*/
+void* loc_timer_start(unsigned int delay_msec,
+                      loc_timer_callback,
+                      void* user_data);
+
+/*
+  handle becomes invalid upon the return of the callback
+*/
+void loc_timer_stop(void* handle);
+
 #ifdef __cplusplus
 }
 #endif /* __cplusplus */
diff --git a/utils/log_util.h b/utils/log_util.h
index 7fb0c78..8ff6b5a 100644
--- a/utils/log_util.h
+++ b/utils/log_util.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2011 The Linux Foundation. All rights reserved.
+/* Copyright (c) 2011-2014 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
@@ -96,37 +96,47 @@ extern char* get_timestamp(char* str, unsigned long buf_size);
   if that value remains unchanged, it means gps.conf did not
   provide a value and we default to the initial value to use
   Android's logging levels*/
+#define IF_LOC_LOGE if((loc_logger.DEBUG_LEVEL >= 1) && (loc_logger.DEBUG_LEVEL <= 5))
+
+#define IF_LOC_LOGW if((loc_logger.DEBUG_LEVEL >= 2) && (loc_logger.DEBUG_LEVEL <= 5))
+
+#define IF_LOC_LOGI if((loc_logger.DEBUG_LEVEL >= 3) && (loc_logger.DEBUG_LEVEL <= 5))
+
+#define IF_LOC_LOGD if((loc_logger.DEBUG_LEVEL >= 4) && (loc_logger.DEBUG_LEVEL <= 5))
+
+#define IF_LOC_LOGV if((loc_logger.DEBUG_LEVEL >= 5) && (loc_logger.DEBUG_LEVEL <= 5))
+
 #define LOC_LOGE(...) \
-if ((loc_logger.DEBUG_LEVEL >= 1) && (loc_logger.DEBUG_LEVEL <= 5)) { ALOGE("W/"__VA_ARGS__); } \
-else if (loc_logger.DEBUG_LEVEL == 0xff) { ALOGE("W/"__VA_ARGS__); }
+IF_LOC_LOGE { ALOGE("E/" __VA_ARGS__); } \
+else if (loc_logger.DEBUG_LEVEL == 0xff) { ALOGE("E/" __VA_ARGS__); }
 
 #define LOC_LOGW(...) \
-if ((loc_logger.DEBUG_LEVEL >= 2) && (loc_logger.DEBUG_LEVEL <= 5)) { ALOGE("W/"__VA_ARGS__); }  \
-else if (loc_logger.DEBUG_LEVEL == 0xff) { ALOGW("W/"__VA_ARGS__); }
+IF_LOC_LOGW { ALOGE("W/" __VA_ARGS__); }  \
+else if (loc_logger.DEBUG_LEVEL == 0xff) { ALOGW("W/" __VA_ARGS__); }
 
 #define LOC_LOGI(...) \
-if ((loc_logger.DEBUG_LEVEL >= 3) && (loc_logger.DEBUG_LEVEL <= 5)) { ALOGE("I/"__VA_ARGS__); }   \
-else if (loc_logger.DEBUG_LEVEL == 0xff) { ALOGI("I/"__VA_ARGS__); }
+IF_LOC_LOGI { ALOGE("I/" __VA_ARGS__); }   \
+else if (loc_logger.DEBUG_LEVEL == 0xff) { ALOGI("I/" __VA_ARGS__); }
 
 #define LOC_LOGD(...) \
-if ((loc_logger.DEBUG_LEVEL >= 4) && (loc_logger.DEBUG_LEVEL <= 5)) { ALOGE("D/"__VA_ARGS__); }   \
-else if (loc_logger.DEBUG_LEVEL == 0xff) { ALOGD("D/"__VA_ARGS__); }
+IF_LOC_LOGD { ALOGE("D/" __VA_ARGS__); }   \
+else if (loc_logger.DEBUG_LEVEL == 0xff) { ALOGD("D/" __VA_ARGS__); }
 
 #define LOC_LOGV(...) \
-if ((loc_logger.DEBUG_LEVEL >= 5) && (loc_logger.DEBUG_LEVEL <= 5)) { ALOGE("V/"__VA_ARGS__); }   \
-else if (loc_logger.DEBUG_LEVEL == 0xff) { ALOGV("V/"__VA_ARGS__); }
+IF_LOC_LOGV { ALOGE("V/" __VA_ARGS__); }   \
+else if (loc_logger.DEBUG_LEVEL == 0xff) { ALOGV("V/" __VA_ARGS__); }
 
 #else /* DEBUG_DMN_LOC_API */
 
-#define LOC_LOGE(...) ALOGE("E/"__VA_ARGS__)
+#define LOC_LOGE(...) ALOGE("E/" __VA_ARGS__)
 
-#define LOC_LOGW(...) ALOGW("W/"__VA_ARGS__)
+#define LOC_LOGW(...) ALOGW("W/" __VA_ARGS__)
 
-#define LOC_LOGI(...) ALOGI("I/"__VA_ARGS__)
+#define LOC_LOGI(...) ALOGI("I/" __VA_ARGS__)
 
-#define LOC_LOGD(...) ALOGD("D/"__VA_ARGS__)
+#define LOC_LOGD(...) ALOGD("D/" __VA_ARGS__)
 
-#define LOC_LOGV(...) ALOGV("V/"__VA_ARGS__)
+#define LOC_LOGV(...) ALOGV("V/" __VA_ARGS__)
 
 #endif /* DEBUG_DMN_LOC_API */