Merge branch 'KK.04.04.02.010.399' into l-pdk

Change-Id: I2452a378d4a4697cec2b023a0e9a9bf3e5f14924

26 files changed, 1315 insertions, 3324 deletions

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/gps.c b/loc_api/libloc_api/gps.c
deleted file mode 100644
index 36bfcb6..0000000
--- a/loc_api/libloc_api/gps.c
+++ /dev/null
@@ -1,68 +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.
- *
- */
-
-#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;
-}
-
-static struct hw_module_methods_t gps_module_methods = {
-    .open = open_gps
-};
-
-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,
-};
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/loc_eng_xtra.h b/loc_api/libloc_api/loc_eng_xtra.h
deleted file mode 100644
index a72b152..0000000
--- a/loc_api/libloc_api/loc_eng_xtra.h
+++ /dev/null
@@ -1,45 +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_XTRA_H
-#define LOC_ENG_XTRA_H
-
-#include <hardware/gps.h>
-
-extern const GpsXtraInterface sLocEngXTRAInterface;
-
-// Module data
-typedef struct
-{
-    // loc_eng_ioctl_cb_data_s_type   ioctl_cb_data;
-    gps_xtra_download_request      download_request_cb;
-
-} loc_eng_xtra_data_s_type;
-
-#endif // LOC_ENG_XTRA_H
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