path: root/gps/libloc_api_50001/loc_eng.cpp

/* Copyright (c) 2009-2012, 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
#define LOG_TAG "LocSvc_eng"

#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <ctype.h>
#include <math.h>
#include <pthread.h>
#include <arpa/inet.h>
#include <netinet/in.h>         /* struct sockaddr_in */
#include <sys/socket.h>
#include <sys/time.h>
#include <netdb.h>
#include <time.h>

#include "LocApiAdapter.h"

#include <cutils/sched_policy.h>
#include <utils/SystemClock.h>
#include <utils/Log.h>
#include <string.h>

#include <loc_eng.h>
#include <loc_eng_ni.h>
#include <loc_eng_dmn_conn.h>
#include <loc_eng_dmn_conn_handler.h>
#include <loc_eng_msg.h>
#include <loc_eng_msg_id.h>
#include <loc_eng_nmea.h>
#include <msg_q.h>
#include <loc.h>

#include "log_util.h"
#include "loc_eng_log.h"

#define SUCCESS TRUE
#define FAILURE FALSE

static void loc_eng_deferred_action_thread(void* context);
static void* loc_eng_create_msg_q();
static void loc_eng_free_msg(void* msg);

pthread_mutex_t LocEngContext::lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t LocEngContext::cond = PTHREAD_COND_INITIALIZER;
LocEngContext* LocEngContext::me = NULL;
boolean gpsConfigAlreadyRead = false;

loc_gps_cfg_s_type gps_conf;

/* Parameter spec table */
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'},
  {"GYRO_BIAS_RANDOM_WALK",          &gps_conf.GYRO_BIAS_RANDOM_WALK,          &gps_conf.GYRO_BIAS_RANDOM_WALK_VALID, 'f'},
  {"ACCEL_RANDOM_WALK_SPECTRAL_DENSITY",     &gps_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY,    &gps_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY_VALID, 'f'},
  {"ANGLE_RANDOM_WALK_SPECTRAL_DENSITY",     &gps_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY,    &gps_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY_VALID, 'f'},
  {"RATE_RANDOM_WALK_SPECTRAL_DENSITY",      &gps_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY,     &gps_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY_VALID, 'f'},
  {"VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY",  &gps_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY, &gps_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY_VALID, 'f'},
  {"SENSOR_ACCEL_BATCHES_PER_SEC",   &gps_conf.SENSOR_ACCEL_BATCHES_PER_SEC,   NULL, 'n'},
  {"SENSOR_ACCEL_SAMPLES_PER_BATCH", &gps_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH, NULL, 'n'},
  {"SENSOR_GYRO_BATCHES_PER_SEC",    &gps_conf.SENSOR_GYRO_BATCHES_PER_SEC,    NULL, 'n'},
  {"SENSOR_GYRO_SAMPLES_PER_BATCH",  &gps_conf.SENSOR_GYRO_SAMPLES_PER_BATCH,  NULL, 'n'},
  {"SENSOR_ACCEL_BATCHES_PER_SEC_HIGH",   &gps_conf.SENSOR_ACCEL_BATCHES_PER_SEC_HIGH,   NULL, 'n'},
  {"SENSOR_ACCEL_SAMPLES_PER_BATCH_HIGH", &gps_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH_HIGH, NULL, 'n'},
  {"SENSOR_GYRO_BATCHES_PER_SEC_HIGH",    &gps_conf.SENSOR_GYRO_BATCHES_PER_SEC_HIGH,    NULL, 'n'},
  {"SENSOR_GYRO_SAMPLES_PER_BATCH_HIGH",  &gps_conf.SENSOR_GYRO_SAMPLES_PER_BATCH_HIGH,  NULL, 'n'},
  {"SENSOR_CONTROL_MODE",            &gps_conf.SENSOR_CONTROL_MODE,            NULL, 'n'},
  {"SENSOR_USAGE",                   &gps_conf.SENSOR_USAGE,                   NULL, 'n'},
  {"SENSOR_ALGORITHM_CONFIG_MASK",   &gps_conf.SENSOR_ALGORITHM_CONFIG_MASK,   NULL, 'n'},
  {"QUIPC_ENABLED",                  &gps_conf.QUIPC_ENABLED,                  NULL, 'n'},
  {"LPP_PROFILE",                    &gps_conf.LPP_PROFILE,                    NULL, 'n'},
};

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;

   gps_conf.GYRO_BIAS_RANDOM_WALK = 0;
   gps_conf.SENSOR_ACCEL_BATCHES_PER_SEC = 2;
   gps_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH = 5;
   gps_conf.SENSOR_GYRO_BATCHES_PER_SEC = 2;
   gps_conf.SENSOR_GYRO_SAMPLES_PER_BATCH = 5;
   gps_conf.SENSOR_ACCEL_BATCHES_PER_SEC_HIGH = 4;
   gps_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH_HIGH = 25;
   gps_conf.SENSOR_GYRO_BATCHES_PER_SEC_HIGH = 4;
   gps_conf.SENSOR_GYRO_SAMPLES_PER_BATCH_HIGH = 25;
   gps_conf.SENSOR_CONTROL_MODE = 0; /* AUTO */
   gps_conf.SENSOR_USAGE = 0; /* Enabled */
   gps_conf.SENSOR_ALGORITHM_CONFIG_MASK = 0; /* INS Disabled = FALSE*/

   /* Values MUST be set by OEMs in configuration for sensor-assisted
      navigation to work. There are NO default values */
   gps_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY = 0;
   gps_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY = 0;
   gps_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY = 0;
   gps_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY = 0;

   gps_conf.GYRO_BIAS_RANDOM_WALK_VALID = 0;
   gps_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY_VALID = 0;
   gps_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY_VALID = 0;
   gps_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY_VALID = 0;
   gps_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY_VALID = 0;

      /* LTE Positioning Profile configuration is disable by default*/
   gps_conf.LPP_PROFILE = 0;
}

LocEngContext::LocEngContext(gps_create_thread threadCreator) :
    deferred_q((const void*)loc_eng_create_msg_q()),
    //TODO: should we conditionally create ulp msg q?
    ulp_q((const void*)loc_eng_create_msg_q()),
    deferred_action_thread(threadCreator("loc_eng",loc_eng_deferred_action_thread, this)),
    counter(0)
{
    LOC_LOGV("LocEngContext %d : %d pthread_id %ld\n",
             getpid(), gettid(),
             deferred_action_thread);
}

LocEngContext* LocEngContext::get(gps_create_thread threadCreator)
{
    pthread_mutex_lock(&lock);
    // gonna need mutex protection here...
    if (NULL == me) {
        me = new LocEngContext(threadCreator);
    }
    me->counter++;

    pthread_mutex_unlock(&lock);
    return me;
}

void LocEngContext::drop()
{
    if (deferred_action_thread != pthread_self()) {
        pthread_mutex_lock(&lock);
        counter--;
        if (counter == 0) {
            loc_eng_msg *msg(new loc_eng_msg(this, LOC_ENG_MSG_QUIT));
            msg_q_snd((void*)deferred_q, msg, loc_eng_free_msg);

            // I am not sure if this is going to be hazardous. The calling thread
            // might be blocked for a while, if the q is loaded.  I am wondering
            // if we should just dump all the msgs in the q upon QUIT.
            pthread_cond_wait(&cond, &lock);

            msg_q_destroy((void**)&deferred_q);
            msg_q_destroy((void**)&ulp_q);
            delete me;
            me = NULL;
        }
        pthread_mutex_unlock(&lock);
    } else {
        LOC_LOGE("The HAL thread cannot free itself");
    }
}

// 2nd half of init(), singled out for
// modem restart to use.
static int loc_eng_reinit(loc_eng_data_s_type &loc_eng_data);
static void loc_eng_agps_reinit(loc_eng_data_s_type &loc_eng_data);

static int loc_eng_set_server(loc_eng_data_s_type &loc_eng_data,
                              LocServerType type, const char *hostname, int port);
// Internal functions
static void loc_inform_gps_status(loc_eng_data_s_type &loc_eng_data,
                                  GpsStatusValue status);
static void loc_eng_report_status(loc_eng_data_s_type &loc_eng_data,
                                  GpsStatusValue status);
static void loc_eng_process_conn_request(loc_eng_data_s_type &loc_eng_data,
                                         int connHandle, AGpsType agps_type);
static void loc_eng_agps_close_status(loc_eng_data_s_type &loc_eng_data, int is_succ);
static void loc_eng_handle_engine_down(loc_eng_data_s_type &loc_eng_data) ;
static void loc_eng_handle_engine_up(loc_eng_data_s_type &loc_eng_data) ;
static int loc_eng_set_privacy(loc_eng_data_s_type &loc_eng_data,
                               int8_t privacy_setting);

static char extra_data[100];
/*********************************************************************
 * 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)

void loc_eng_msg_sender(void* loc_eng_data_p, void* msg)
{
    LocEngContext* loc_eng_context = (LocEngContext*)((loc_eng_data_s_type*)loc_eng_data_p)->context;
    msg_q_snd((void*)loc_eng_context->deferred_q, msg, loc_eng_free_msg);
}

static void* loc_eng_create_msg_q()
{
    void* q = NULL;
    if (eMSG_Q_SUCCESS != msg_q_init(&q)) {
        LOC_LOGE("loc_eng_create_msg_q Q init failed.");
        q = NULL;
    }
    return q;
}

static void loc_eng_free_msg(void* msg)
{
    delete (loc_eng_msg*)msg;
}

/*===========================================================================
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

===========================================================================*/
int loc_eng_init(loc_eng_data_s_type &loc_eng_data, LocCallbacks* callbacks,
                 LOC_API_ADAPTER_EVENT_MASK_T event,
                  void (*loc_external_msg_sender) (void*, void*))

{
    int ret_val =-1;

    ENTRY_LOG_CALLFLOW();
    if (NULL == callbacks || 0 == event) {
        LOC_LOGE("loc_eng_init: bad parameters cb %p eMask %d", callbacks, event);
        EXIT_LOG(%d, ret_val);
        return ret_val;
    }

    if (NULL != loc_eng_data.context) {
        // Current loc_eng_cleanup keeps context initialized, so must enable
        // here too.
        loc_eng_set_privacy(loc_eng_data, 1);
    }

    STATE_CHECK((NULL == loc_eng_data.context),
                "instance already initialized", return 0);

    memset(&loc_eng_data, 0, sizeof (loc_eng_data));

    // Create context (msg q + thread) (if not yet created)
    // This will also parse gps.conf, if not done.
    loc_eng_data.context = (void*)LocEngContext::get(callbacks->create_thread_cb);
    if (NULL != callbacks->set_capabilities_cb) {
        callbacks->set_capabilities_cb(gps_conf.CAPABILITIES);
    }

    // Save callbacks
    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;
    loc_eng_data.request_utc_time_cb = callbacks->request_utc_time_cb;
    loc_eng_data.intermediateFix = gps_conf.INTERMEDIATE_POS;

    // 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;
    // loc_eng_data.mute_session_state -- LOC_MUTE_SESS_NONE;

    if ((event & LOC_API_ADAPTER_BIT_NMEA_1HZ_REPORT) && (gps_conf.NMEA_PROVIDER == NMEA_PROVIDER_AP))
    {
        event = event ^ LOC_API_ADAPTER_BIT_NMEA_1HZ_REPORT; // unregister for modem NMEA report
        loc_eng_data.generateNmea = true;
    }
    else
    {
        loc_eng_data.generateNmea = false;
    }

    LocEng locEngHandle(&loc_eng_data, event, loc_eng_data.acquire_wakelock_cb,
                        loc_eng_data.release_wakelock_cb, loc_eng_msg_sender, loc_external_msg_sender,
                        callbacks->location_ext_parser, callbacks->sv_ext_parser);
    loc_eng_data.client_handle = LocApiAdapter::getLocApiAdapter(locEngHandle);

    if (NULL == loc_eng_data.client_handle) {
        // drop the context and declare failure
        ((LocEngContext*)(loc_eng_data.context))->drop();
        loc_eng_data.context = NULL;
    } else {
        LOC_LOGD("loc_eng_init created client, id = %p\n", loc_eng_data.client_handle);

        // call reinit to send initialization messages
       int tries = 30;
       while (tries > 0 &&
              LOC_API_ADAPTER_ERR_SUCCESS != (ret_val = loc_eng_reinit(loc_eng_data))) {
           tries--;
           LOC_LOGD("loc_eng_init client open failed, %d more tries", tries);
           sleep(1);
       }

        if (LOC_API_ADAPTER_ERR_SUCCESS == ret_val) {
            loc_eng_set_privacy(loc_eng_data, 1);
        }
    }

    EXIT_LOG(%d, ret_val);
    return ret_val;
}

static int loc_eng_reinit(loc_eng_data_s_type &loc_eng_data)
{
    ENTRY_LOG();
    int ret_val = loc_eng_data.client_handle->reinit();

    if (LOC_API_ADAPTER_ERR_SUCCESS == ret_val) {
        LOC_LOGD("loc_eng_reinit reinit() successful");

        loc_eng_msg_suple_version *supl_msg(new loc_eng_msg_suple_version(&loc_eng_data,
                                                                          gps_conf.SUPL_VER));
        msg_q_snd((void*)((LocEngContext*)(loc_eng_data.context))->deferred_q,
                  supl_msg, loc_eng_free_msg);

        loc_eng_msg_lpp_config *lpp_msg(new loc_eng_msg_lpp_config(&loc_eng_data,
                                                                          gps_conf.LPP_PROFILE));
        msg_q_snd((void*)((LocEngContext*)(loc_eng_data.context))->deferred_q,
                  lpp_msg, loc_eng_free_msg);

        loc_eng_msg_sensor_control_config *sensor_control_config_msg(
            new loc_eng_msg_sensor_control_config(&loc_eng_data, gps_conf.SENSOR_USAGE));
        msg_q_snd((void*)((LocEngContext*)(loc_eng_data.context))->deferred_q,
                  sensor_control_config_msg, loc_eng_free_msg);

        /* Make sure at least one of the sensor property is specified by the user in the gps.conf file. */
        if( gps_conf.GYRO_BIAS_RANDOM_WALK_VALID ||
            gps_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY_VALID ||
            gps_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY_VALID ||
            gps_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY_VALID ||
            gps_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY_VALID )
        {
            loc_eng_msg_sensor_properties *sensor_properties_msg(
                new loc_eng_msg_sensor_properties(&loc_eng_data,
                                                   gps_conf.GYRO_BIAS_RANDOM_WALK_VALID,
                                                   gps_conf.GYRO_BIAS_RANDOM_WALK,
                                                   gps_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY_VALID,
                                                   gps_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY,
                                                   gps_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY_VALID,
                                                   gps_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY,
                                                   gps_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY_VALID,
                                                   gps_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY,
                                                   gps_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY_VALID,
                                                   gps_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY));
            msg_q_snd((void*)((LocEngContext*)(loc_eng_data.context))->deferred_q,
                      sensor_properties_msg, loc_eng_free_msg);
        }

        loc_eng_msg_sensor_perf_control_config *sensor_perf_control_conf_msg(
            new loc_eng_msg_sensor_perf_control_config(&loc_eng_data,
                                                       gps_conf.SENSOR_CONTROL_MODE,
                                                       gps_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH,
                                                       gps_conf.SENSOR_ACCEL_BATCHES_PER_SEC,
                                                       gps_conf.SENSOR_GYRO_SAMPLES_PER_BATCH,
                                                       gps_conf.SENSOR_GYRO_BATCHES_PER_SEC,
                                                       gps_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH_HIGH,
                                                       gps_conf.SENSOR_ACCEL_BATCHES_PER_SEC_HIGH,
                                                       gps_conf.SENSOR_GYRO_SAMPLES_PER_BATCH_HIGH,
                                                       gps_conf.SENSOR_GYRO_BATCHES_PER_SEC_HIGH,
                                                       gps_conf.SENSOR_ALGORITHM_CONFIG_MASK));
        msg_q_snd((void*)((LocEngContext*)(loc_eng_data.context))->deferred_q,
                  sensor_perf_control_conf_msg, loc_eng_free_msg);
    }

    EXIT_LOG(%d, ret_val);
    return ret_val;
}

/*===========================================================================
FUNCTION    loc_eng_cleanup

DESCRIPTION
   Cleans location engine. The location client handle will be released.

DEPENDENCIES
   None

RETURN VALUE
   None

SIDE EFFECTS
   N/A

===========================================================================*/
void loc_eng_cleanup(loc_eng_data_s_type &loc_eng_data)
{
    ENTRY_LOG_CALLFLOW();
    INIT_CHECK(loc_eng_data.context, return);

    // XTRA has no state, so we are fine with it.

    // we need to check and clear NI
#if 0
    // we need to check and clear ATL
    if (NULL != loc_eng_data.agnss_nif) {
        delete loc_eng_data.agnss_nif;
        loc_eng_data.agnss_nif = NULL;
    }
    if (NULL != loc_eng_data.internet_nif) {
        delete loc_eng_data.internet_nif;
        loc_eng_data.internet_nif = NULL;
    }
#endif
    if (loc_eng_data.client_handle->isInSession())
    {
        LOC_LOGD("loc_eng_cleanup: fix not stopped. stop it now.");
        loc_eng_stop(loc_eng_data);
    }

    loc_eng_set_privacy(loc_eng_data, 0);

#if 0 // can't afford to actually clean up, for many reason.

    ((LocEngContext*)(loc_eng_data.context))->drop();
    loc_eng_data.context = NULL;

    // De-initialize ulp
    if (locEngUlpInf != NULL)
    {
        locEngUlpInf = NULL;
        msg_q_destroy( &loc_eng_data.ulp_q);
    }

    if (loc_eng_data.client_handle != NULL)
    {
        LOC_LOGD("loc_eng_init: client opened. close it now.");
        delete loc_eng_data.client_handle;
        loc_eng_data.client_handle = NULL;
    }

#ifdef FEATURE_GNSS_BIT_API
    {
        char baseband[PROPERTY_VALUE_MAX];
        property_get("ro.baseband", baseband, "msm");
        if ((strcmp(baseband,"svlte2a") == 0))
        {
            loc_eng_dmn_conn_loc_api_server_unblock();
            loc_eng_dmn_conn_loc_api_server_join();
        }
    }
#endif /* FEATURE_GNSS_BIT_API */

#endif

    EXIT_LOG(%s, VOID_RET);
}


/*===========================================================================
FUNCTION    loc_eng_start

DESCRIPTION
   Starts the tracking session

DEPENDENCIES
   None

RETURN VALUE
   0: success

SIDE EFFECTS
   N/A

===========================================================================*/
int loc_eng_start(loc_eng_data_s_type &loc_eng_data)
{
   ENTRY_LOG_CALLFLOW();
   INIT_CHECK(loc_eng_data.context, return -1);

   if((loc_eng_data.ulp_initialized == true) && (gps_conf.CAPABILITIES & ULP_CAPABILITY))
   {
       //Pass the start messgage to ULP if present & activated
       loc_eng_msg *msg(new loc_eng_msg(&loc_eng_data, ULP_MSG_START_FIX));
       msg_q_snd( (void*)((LocEngContext*)(loc_eng_data.context))->ulp_q,
                  msg, loc_eng_free_msg);
   }else
   {
       loc_eng_msg *msg(new loc_eng_msg(&loc_eng_data, LOC_ENG_MSG_START_FIX));
       msg_q_snd((void*)((LocEngContext*)(loc_eng_data.context))->deferred_q,
                 msg, loc_eng_free_msg);
   }
   EXIT_LOG(%d, 0);
   return 0;
}

static int loc_eng_start_handler(loc_eng_data_s_type &loc_eng_data)
{
   ENTRY_LOG();
   int ret_val = LOC_API_ADAPTER_ERR_SUCCESS;

   if (!loc_eng_data.client_handle->isInSession()) {
       ret_val = loc_eng_data.client_handle->startFix();

       if (ret_val == LOC_API_ADAPTER_ERR_SUCCESS ||
           ret_val == LOC_API_ADAPTER_ERR_ENGINE_DOWN)
       {
           loc_eng_data.client_handle->setInSession(TRUE);
           loc_inform_gps_status(loc_eng_data, GPS_STATUS_SESSION_BEGIN);
       }
   }

   EXIT_LOG(%d, ret_val);
   return ret_val;
}

/*===========================================================================
FUNCTION    loc_eng_stop_wrapper

DESCRIPTION
   Stops the tracking session

DEPENDENCIES
   None

RETURN VALUE
   0: success

SIDE EFFECTS
   N/A

===========================================================================*/
int loc_eng_stop(loc_eng_data_s_type &loc_eng_data)
{
    ENTRY_LOG_CALLFLOW();
    INIT_CHECK(loc_eng_data.context, return -1);

    if((loc_eng_data.ulp_initialized == true) && (gps_conf.CAPABILITIES & ULP_CAPABILITY))
    {
        //Pass the start messgage to ULP if present & activated
        loc_eng_msg *msg(new loc_eng_msg(&loc_eng_data, ULP_MSG_STOP_FIX));
        msg_q_snd( (void*)((LocEngContext*)(loc_eng_data.context))->ulp_q,
                   msg, loc_eng_free_msg);
    }else
    {
        loc_eng_msg *msg(new loc_eng_msg(&loc_eng_data, LOC_ENG_MSG_STOP_FIX));
        msg_q_snd((void*)((LocEngContext*)(loc_eng_data.context))->deferred_q,
                  msg, loc_eng_free_msg);
    }

    EXIT_LOG(%d, 0);
    return 0;
}

static int loc_eng_stop_handler(loc_eng_data_s_type &loc_eng_data)
{
   ENTRY_LOG();
   int ret_val = LOC_API_ADAPTER_ERR_SUCCESS;

   if (loc_eng_data.client_handle->isInSession()) {

       ret_val = loc_eng_data.client_handle->stopFix();
       if (ret_val == LOC_API_ADAPTER_ERR_SUCCESS)
       {
           loc_inform_gps_status(loc_eng_data, GPS_STATUS_SESSION_END);
       }

       loc_eng_data.client_handle->setInSession(FALSE);
   }

    EXIT_LOG(%d, ret_val);
    return ret_val;
}

/*===========================================================================
FUNCTION    loc_eng_mute_one_session

DESCRIPTION
   Mutes one session

DEPENDENCIES
   None

RETURN VALUE
   0: Success

SIDE EFFECTS
   N/A

===========================================================================*/
void loc_eng_mute_one_session(loc_eng_data_s_type &loc_eng_data)
{
    ENTRY_LOG();
    loc_eng_data.mute_session_state = LOC_MUTE_SESS_WAIT;
    EXIT_LOG(%s, VOID_RET);
}

/*===========================================================================
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

===========================================================================*/
int loc_eng_set_position_mode(loc_eng_data_s_type &loc_eng_data,
                              LocPosMode &params)
{
    ENTRY_LOG_CALLFLOW();
    INIT_CHECK(loc_eng_data.context, return -1);
    loc_eng_msg_position_mode *msg(
        new loc_eng_msg_position_mode(&loc_eng_data, params));
    msg_q_snd((void*)((LocEngContext*)(loc_eng_data.context))->deferred_q,
              msg, loc_eng_free_msg);

    EXIT_LOG(%d, 0);
    return 0;
}

/*===========================================================================
FUNCTION    loc_eng_inject_time

DESCRIPTION
   This is used by Java native function to do time injection.

DEPENDENCIES
   None

RETURN VALUE
   0

SIDE EFFECTS
   N/A

===========================================================================*/
int loc_eng_inject_time(loc_eng_data_s_type &loc_eng_data, GpsUtcTime time,
                        int64_t timeReference, int uncertainty)
{
    ENTRY_LOG_CALLFLOW();
    INIT_CHECK(loc_eng_data.context, return -1);
    loc_eng_msg_set_time *msg(
        new loc_eng_msg_set_time(&loc_eng_data,
                                 time,
                                 timeReference,
                                 uncertainty));
    msg_q_snd((void*)((LocEngContext*)(loc_eng_data.context))->deferred_q,
              msg, loc_eng_free_msg);
    EXIT_LOG(%d, 0);
    return 0;
}


/*===========================================================================
FUNCTION    loc_eng_inject_location

DESCRIPTION
   This is used by Java native function to do location injection.

DEPENDENCIES
   None

RETURN VALUE
   0          : Successful
   error code : Failure

SIDE EFFECTS
   N/A
===========================================================================*/
int loc_eng_inject_location(loc_eng_data_s_type &loc_eng_data, double latitude,
                            double longitude, float accuracy)
{
    ENTRY_LOG_CALLFLOW();
    INIT_CHECK(loc_eng_data.context, return -1);
    loc_eng_msg_inject_location *msg(
        new loc_eng_msg_inject_location(&loc_eng_data,
                                        latitude,
                                        longitude,
                                        accuracy));
    msg_q_snd((void*)((LocEngContext*)(loc_eng_data.context))->deferred_q,
              msg, loc_eng_free_msg);

    EXIT_LOG(%d, 0);
    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
   None

SIDE EFFECTS
   N/A

===========================================================================*/
void loc_eng_delete_aiding_data(loc_eng_data_s_type &loc_eng_data, GpsAidingData f)
{
    ENTRY_LOG_CALLFLOW();
    INIT_CHECK(loc_eng_data.context, return);

    loc_eng_msg_delete_aiding_data *msg(
        new loc_eng_msg_delete_aiding_data(&loc_eng_data,
                                           f));
    msg_q_snd((void*)((LocEngContext*)(loc_eng_data.context))->deferred_q,
              msg, loc_eng_free_msg);

    EXIT_LOG(%s, VOID_RET);
}

/*===========================================================================

FUNCTION    loc_inform_gps_state

DESCRIPTION
   Informs the GPS Provider about the GPS status

DEPENDENCIES
   None

RETURN VALUE
   None

SIDE EFFECTS
   N/A

===========================================================================*/
static void loc_inform_gps_status(loc_eng_data_s_type &loc_eng_data, GpsStatusValue status)
{
    ENTRY_LOG();

    static GpsStatusValue last_status = GPS_STATUS_NONE;

    GpsStatus gs = { sizeof(gs),status };


    if (loc_eng_data.status_cb)
    {
        CALLBACK_LOG_CALLFLOW("status_cb", %s, loc_get_gps_status_name(gs.status));
        loc_eng_data.status_cb(&gs);
    }

    last_status = status;

    EXIT_LOG(%s, VOID_RET);
}

/*===========================================================================
FUNCTION    loc_eng_agps_reinit

DESCRIPTION
   2nd half of loc_eng_agps_init(), singled out for modem restart to use.

DEPENDENCIES
   NONE

RETURN VALUE
   0

SIDE EFFECTS
   N/A

===========================================================================*/
static void loc_eng_agps_reinit(loc_eng_data_s_type &loc_eng_data)
{
    ENTRY_LOG();

    // Set server addresses which came before init
    if (loc_eng_data.supl_host_set)
    {
        loc_eng_set_server(loc_eng_data, LOC_AGPS_SUPL_SERVER,
                           loc_eng_data.supl_host_buf,
                           loc_eng_data.supl_port_buf);
    }

    if (loc_eng_data.c2k_host_set)
    {
        loc_eng_set_server(loc_eng_data, LOC_AGPS_CDMA_PDE_SERVER,
                           loc_eng_data.c2k_host_buf,
                           loc_eng_data.c2k_port_buf);
    }
    EXIT_LOG(%s, VOID_RET);
}
/*===========================================================================
FUNCTION    loc_eng_agps_init

DESCRIPTION
   Initialize the AGps interface.

DEPENDENCIES
   NONE

RETURN VALUE
   0

SIDE EFFECTS
   N/A

===========================================================================*/
void loc_eng_agps_init(loc_eng_data_s_type &loc_eng_data, AGpsCallbacks* callbacks)
{
    ENTRY_LOG_CALLFLOW();
    INIT_CHECK(loc_eng_data.context, return);
    STATE_CHECK((NULL == loc_eng_data.agps_status_cb),
                "agps instance already initialized",
                return);
    if(callbacks == NULL) {
        LOC_LOGE("loc_eng_agps_init: bad parameters cb %p", callbacks);
        EXIT_LOG(%s, VOID_RET);
        return;
    }
    loc_eng_data.agps_status_cb = callbacks->status_cb;

    loc_eng_data.agnss_nif = new AgpsStateMachine(loc_eng_data.agps_status_cb,
                                                  AGPS_TYPE_SUPL,
                                                  false);
    loc_eng_data.internet_nif = new AgpsStateMachine(loc_eng_data.agps_status_cb,
                                                     AGPS_TYPE_WWAN_ANY,
                                                     false);
    loc_eng_data.wifi_nif = new AgpsStateMachine(loc_eng_data.agps_status_cb,
                                                 AGPS_TYPE_WIFI,
                                                 true);

#ifdef FEATURE_GNSS_BIT_API
    {
        char baseband[PROPERTY_VALUE_MAX];
        property_get("ro.baseband", baseband, "msm");
        if ((strcmp(baseband,"svlte2a") == 0) ||
            (strcmp(baseband,"sglte") == 0) ||
            (strcmp(baseband,"msm") == 0))
        {
            loc_eng_dmn_conn_loc_api_server_launch(callbacks->create_thread_cb,
                                                   NULL, NULL, &loc_eng_data);
        } else {
            LOC_LOGD("%s:%d] loc_eng_dmn_conn_loc_api_server was not initialized.baseband = %s\n",
            __func__, __LINE__, baseband);
        }
    }
#endif /* FEATURE_GNSS_BIT_API */

    loc_eng_agps_reinit(loc_eng_data);
    EXIT_LOG(%s, VOID_RET);
}

/*===========================================================================
FUNCTION    loc_eng_agps_open

DESCRIPTION
   This function is called when on-demand data connection opening is successful.
It should inform engine about the data open result.

DEPENDENCIES
   NONE

RETURN VALUE
   0

SIDE EFFECTS
   N/A

===========================================================================*/
int loc_eng_agps_open(loc_eng_data_s_type &loc_eng_data, AGpsType agpsType,
                     const char* apn, AGpsBearerType bearerType)
{
    ENTRY_LOG_CALLFLOW();
    INIT_CHECK(loc_eng_data.context && loc_eng_data.agps_status_cb,
               return -1);

    if (apn == NULL)
    {
        LOC_LOGE("APN Name NULL\n");
        return 0;
    }

    LOC_LOGD("loc_eng_agps_open APN name = [%s]", apn);

    int apn_len = smaller_of(strlen (apn), MAX_APN_LEN);
    loc_eng_msg_atl_open_success *msg(
        new loc_eng_msg_atl_open_success(&loc_eng_data, agpsType, apn,
                                        apn_len, bearerType));
    msg_q_snd((void*)((LocEngContext*)(loc_eng_data.context))->deferred_q,
              msg, loc_eng_free_msg);

    EXIT_LOG(%d, 0);
    return 0;
}

/*===========================================================================
FUNCTION    loc_eng_agps_closed

DESCRIPTION
   This function is called when on-demand data connection closing is done.
It should inform engine about the data close result.

DEPENDENCIES
   NONE

RETURN VALUE
   0

SIDE EFFECTS
   N/A

===========================================================================*/
int loc_eng_agps_closed(loc_eng_data_s_type &loc_eng_data, AGpsType agpsType)
{
    ENTRY_LOG_CALLFLOW();
    INIT_CHECK(loc_eng_data.context && loc_eng_data.agps_status_cb,
               return -1);

    loc_eng_msg_atl_closed *msg(new loc_eng_msg_atl_closed(&loc_eng_data, agpsType));
    msg_q_snd((void*)((LocEngContext*)(loc_eng_data.context))->deferred_q,
              msg, loc_eng_free_msg);

    EXIT_LOG(%d, 0);
    return 0;
}

/*===========================================================================
FUNCTION    loc_eng_agps_open_failed

DESCRIPTION
   This function is called when on-demand data connection opening has failed.
It should inform engine about the data open result.

DEPENDENCIES
   NONE

RETURN VALUE
   0

SIDE EFFECTS
   N/A

===========================================================================*/
int loc_eng_agps_open_failed(loc_eng_data_s_type &loc_eng_data, AGpsType agpsType)
{
    ENTRY_LOG_CALLFLOW();
    INIT_CHECK(loc_eng_data.context && loc_eng_data.agps_status_cb,
               return -1);

    loc_eng_msg_atl_open_failed *msg(new loc_eng_msg_atl_open_failed(&loc_eng_data, agpsType));
    msg_q_snd((void*)((LocEngContext*)(loc_eng_data.context))->deferred_q,
              msg, loc_eng_free_msg);

    EXIT_LOG(%d, 0);
    return 0;
}

/*===========================================================================

FUNCTION resolve_in_addr

DESCRIPTION
   Translates a hostname to in_addr struct

DEPENDENCIES
   n/a

RETURN VALUE
   TRUE if successful

SIDE EFFECTS
   n/a

===========================================================================*/
static boolean resolve_in_addr(const char *host_addr, struct in_addr *in_addr_ptr)
{
    ENTRY_LOG();
    boolean ret_val = TRUE;

    struct hostent             *hp;
    hp = gethostbyname(host_addr);
    if (hp != NULL) /* DNS OK */
    {
        memcpy(in_addr_ptr, hp->h_addr_list[0], hp->h_length);
    }
    else
    {
        /* Try IP representation */
        if (inet_aton(host_addr, in_addr_ptr) == 0)
        {
            /* IP not valid */
            LOC_LOGE("DNS query on '%s' failed\n", host_addr);
            ret_val = FALSE;
        }
    }

    EXIT_LOG(%s, loc_logger_boolStr[ret_val!=0]);
    return ret_val;
}

/*===========================================================================
FUNCTION    loc_eng_set_server

DESCRIPTION
   This is used to set the default AGPS server. Server address is obtained
   from gps.conf.

DEPENDENCIES
   NONE

RETURN VALUE
   0

SIDE EFFECTS
   N/A

===========================================================================*/
static int loc_eng_set_server(loc_eng_data_s_type &loc_eng_data,
                              LocServerType type, const char* hostname, int port)
{
    ENTRY_LOG();
    int ret = 0;

    if (LOC_AGPS_SUPL_SERVER == type) {
        char url[MAX_URL_LEN];
        unsigned int len = snprintf(url, sizeof(url), "%s:%u", hostname, (unsigned) port);

        if (sizeof(url) > len) {
            loc_eng_msg_set_server_url *msg(new loc_eng_msg_set_server_url(&loc_eng_data,
                                                                           url, len));
            msg_q_snd((void*)((LocEngContext*)(loc_eng_data.context))->deferred_q,
                      msg, loc_eng_free_msg);
        }
    } else if (LOC_AGPS_CDMA_PDE_SERVER == type ||
               LOC_AGPS_CUSTOM_PDE_SERVER == type ||
               LOC_AGPS_MPC_SERVER == type) {
        struct in_addr addr;
        if (!resolve_in_addr(hostname, &addr))
        {
            LOC_LOGE("loc_eng_set_server, hostname %s cannot be resolved.\n", hostname);
            ret = -2;
        } else {
            unsigned int ip = htonl(addr.s_addr);
            loc_eng_msg_set_server_ipv4 *msg(new loc_eng_msg_set_server_ipv4(&loc_eng_data,
                                                                             ip,
                                                                             port,
                                                                             type));
            msg_q_snd((void*)((LocEngContext*)(loc_eng_data.context))->deferred_q,
                      msg, loc_eng_free_msg);
        }
    } else {
        LOC_LOGE("loc_eng_set_server, type %d cannot be resolved.\n", type);
    }

    EXIT_LOG(%d, ret);
    return ret;
}

/*===========================================================================
FUNCTION    loc_eng_set_server_proxy

DESCRIPTION
   If loc_eng_set_server is called before loc_eng_init, it doesn't work. This
   proxy buffers server settings and calls loc_eng_set_server when the client is
   open.

DEPENDENCIES
   NONE

RETURN VALUE
   0

SIDE EFFECTS
   N/A

===========================================================================*/
int loc_eng_set_server_proxy(loc_eng_data_s_type &loc_eng_data,
                             LocServerType type,
                             const char* hostname, int port)
{
    ENTRY_LOG_CALLFLOW();
    int ret_val = 0;

    if (NULL != loc_eng_data.context)
    {
        ret_val = loc_eng_set_server(loc_eng_data, type, hostname, port);
    } else {
        LOC_LOGW("set_server called before init. save the address, type: %d, hostname: %s, port: %d",
                 (int) type, hostname, port);
        switch (type)
        {
        case LOC_AGPS_SUPL_SERVER:
            strlcpy(loc_eng_data.supl_host_buf, hostname,
                    sizeof(loc_eng_data.supl_host_buf));
            loc_eng_data.supl_port_buf = port;
            loc_eng_data.supl_host_set = 1;
            break;
        case LOC_AGPS_CDMA_PDE_SERVER:
            strlcpy(loc_eng_data.c2k_host_buf, hostname,
                    sizeof(loc_eng_data.c2k_host_buf));
            loc_eng_data.c2k_port_buf = port;
            loc_eng_data.c2k_host_set = 1;
            break;
        default:
            LOC_LOGE("loc_eng_set_server_proxy, unknown server type = %d", (int) type);
        }
    }

    EXIT_LOG(%d, ret_val);
    return ret_val;
}

/*===========================================================================
FUNCTION    loc_eng_agps_ril_update_network_availability

DESCRIPTION
   Sets data call allow vs disallow flag to modem
   This is the only member of sLocEngAGpsRilInterface implemented.

DEPENDENCIES
   None

RETURN VALUE
   0: success

SIDE EFFECTS
   N/A

===========================================================================*/
void loc_eng_agps_ril_update_network_availability(loc_eng_data_s_type &loc_eng_data,
                                                  int available, const char* apn)
{
    ENTRY_LOG_CALLFLOW();
    INIT_CHECK(loc_eng_data.context, return);
    if (apn != NULL)
    {
        LOC_LOGD("loc_eng_agps_ril_update_network_availability: APN Name = [%s]\n", apn);
        int apn_len = smaller_of(strlen (apn), MAX_APN_LEN);
        loc_eng_msg_set_data_enable *msg(new loc_eng_msg_set_data_enable(&loc_eng_data, apn,
                                                                         apn_len, available));
        msg_q_snd((void*)((LocEngContext*)(loc_eng_data.context))->deferred_q,
                  msg, loc_eng_free_msg);
    }
    EXIT_LOG(%s, VOID_RET);
}

/*===========================================================================
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 (loc_eng_data_s_type &loc_eng_data, GpsStatusValue status)
{
    ENTRY_LOG();
    // Switch from WAIT to MUTE, for "engine on" or "session begin" event
    if (status == GPS_STATUS_SESSION_BEGIN || status == GPS_STATUS_ENGINE_ON)
    {
        if (loc_eng_data.mute_session_state == LOC_MUTE_SESS_WAIT)
        {
            LOC_LOGD("loc_eng_report_status: mute_session_state changed from WAIT to IN SESSION");
            loc_eng_data.mute_session_state = LOC_MUTE_SESS_IN_SESSION;
        }
    }

    // Switch off MUTE session
    if (loc_eng_data.mute_session_state == LOC_MUTE_SESS_IN_SESSION &&
        (status == GPS_STATUS_SESSION_END || status == GPS_STATUS_ENGINE_OFF))
    {
        LOC_LOGD("loc_eng_report_status: mute_session_state changed from IN SESSION to NONE");
        loc_eng_data.mute_session_state = LOC_MUTE_SESS_NONE;
    }

    // Session End is not reported during Android navigating state
    boolean navigating = loc_eng_data.client_handle->isInSession();
    if (status != GPS_STATUS_NONE &&
        !(status == GPS_STATUS_SESSION_END && navigating) &&
        !(status == GPS_STATUS_SESSION_BEGIN && !navigating))
    {
        if (loc_eng_data.mute_session_state != LOC_MUTE_SESS_IN_SESSION)
        {
            // Inform GpsLocationProvider about mNavigating status
            loc_inform_gps_status(loc_eng_data, status);
        }
        else {
            LOC_LOGD("loc_eng_report_status: muting the status report.");
        }
    }

    // Only keeps ENGINE ON/OFF in engine_status
    if (status == GPS_STATUS_ENGINE_ON || status == GPS_STATUS_ENGINE_OFF)
    {
        loc_eng_data.engine_status = status;
    }

    // Only keeps SESSION BEGIN/END in fix_session_status
    if (status == GPS_STATUS_SESSION_BEGIN || status == GPS_STATUS_SESSION_END)
    {
        loc_eng_data.fix_session_status = status;
    }
    EXIT_LOG(%s, VOID_RET);
}

/*===========================================================================
FUNCTION loc_eng_handle_engine_down
         loc_eng_handle_engine_up

DESCRIPTION
   Calls this function when it is detected that modem restart is happening.
   Either we detected the modem is down or received modem up event.
   This must be called from the deferred thread to avoid race condition.

DEPENDENCIES
   None

RETURN VALUE
   None

SIDE EFFECTS
   N/A

===========================================================================*/
void loc_eng_handle_engine_down(loc_eng_data_s_type &loc_eng_data)
{
    ENTRY_LOG();
    loc_eng_ni_reset_on_engine_restart(loc_eng_data);
    loc_eng_report_status(loc_eng_data, GPS_STATUS_ENGINE_OFF);
    EXIT_LOG(%s, VOID_RET);
}

void loc_eng_handle_engine_up(loc_eng_data_s_type &loc_eng_data)
{
    ENTRY_LOG();
    loc_eng_reinit(loc_eng_data);

    if (loc_eng_data.agps_status_cb != NULL) {
        loc_eng_data.agnss_nif->dropAllSubscribers();
        loc_eng_data.internet_nif->dropAllSubscribers();

        loc_eng_agps_reinit(loc_eng_data);
    }

    loc_eng_report_status(loc_eng_data, GPS_STATUS_ENGINE_ON);

    // modem is back up.  If we crashed in the middle of navigating, we restart.
    if (loc_eng_data.client_handle->isInSession()) {
        // This sets the copy in adapter to modem
        loc_eng_data.client_handle->setPositionMode(NULL);
        loc_eng_data.client_handle->setInSession(false);
        loc_eng_start_handler(loc_eng_data);
    }
    EXIT_LOG(%s, VOID_RET);
}

/*===========================================================================
FUNCTION loc_eng_deferred_action_thread

DESCRIPTION
   Main routine for the thread to execute loc_eng commands.

DEPENDENCIES
   None

RETURN VALUE
   None

SIDE EFFECTS
   N/A

===========================================================================*/
static void loc_eng_deferred_action_thread(void* arg)
{
    ENTRY_LOG();
    loc_eng_msg *msg;
    static int cnt = 0;
    LocEngContext* context = (LocEngContext*)arg;

    // make sure we do not run in background scheduling group
    set_sched_policy(gettid(), SP_FOREGROUND);

    while (1)
    {
        LOC_LOGD("%s:%d] %d listening ...\n", __func__, __LINE__, cnt++);

        // we are only sending / receiving msg pointers
        msq_q_err_type result = msg_q_rcv((void*)context->deferred_q, (void **) &msg);
        if (eMSG_Q_SUCCESS != result) {
            LOC_LOGE("%s:%d] fail receiving msg: %s\n", __func__, __LINE__,
                     loc_get_msg_q_status(result));
            return;
        }

        loc_eng_data_s_type* loc_eng_data_p = (loc_eng_data_s_type*)msg->owner;

        LOC_LOGD("%s:%d] received msg_id = %s context = %p\n",
                 __func__, __LINE__, loc_get_msg_name(msg->msgid), loc_eng_data_p->context);

        // need to ensure the instance data is valid
        STATE_CHECK(NULL != loc_eng_data_p->context,
                    "instance cleanup happened",
                    delete msg; return);

        switch(msg->msgid) {
        case LOC_ENG_MSG_QUIT:
        {
            LocEngContext* context = (LocEngContext*)loc_eng_data_p->context;
            pthread_mutex_lock(&(context->lock));
            pthread_cond_signal(&(context->cond));
            pthread_mutex_unlock(&(context->lock));
            EXIT_LOG(%s, "LOC_ENG_MSG_QUIT, signal the main thread and return");
        }
        return;

        case LOC_ENG_MSG_REQUEST_NI:
        {
            loc_eng_msg_request_ni *niMsg = (loc_eng_msg_request_ni*)msg;
            loc_eng_ni_request_handler(*loc_eng_data_p, &niMsg->notify, niMsg->passThroughData);
        }
        break;

        case LOC_ENG_MSG_INFORM_NI_RESPONSE:
        {
            loc_eng_msg_inform_ni_response *nrMsg = (loc_eng_msg_inform_ni_response*)msg;
            loc_eng_data_p->client_handle->informNiResponse(nrMsg->response,
                                                            nrMsg->passThroughData);
        }
        break;

        case LOC_ENG_MSG_START_FIX:
            loc_eng_start_handler(*loc_eng_data_p);
            break;

        case LOC_ENG_MSG_STOP_FIX:
            if (loc_eng_data_p->agps_request_pending)
            {
                loc_eng_data_p->stop_request_pending = true;
                LOC_LOGD("loc_eng_stop - deferring stop until AGPS data call is finished\n");
            } else {
                loc_eng_stop_handler(*loc_eng_data_p);
            }
            break;

        case LOC_ENG_MSG_SET_POSITION_MODE:
        {
            loc_eng_msg_position_mode *pmMsg = (loc_eng_msg_position_mode*)msg;
            loc_eng_data_p->client_handle->setPositionMode(&(pmMsg->pMode));
        }
        break;

        case LOC_ENG_MSG_SET_TIME:
        {
            loc_eng_msg_set_time *tMsg = (loc_eng_msg_set_time*)msg;
            loc_eng_data_p->client_handle->setTime(tMsg->time, tMsg->timeReference,
                                                   tMsg->uncertainty);
        }
        break;

        case LOC_ENG_MSG_INJECT_LOCATION:
        {
            loc_eng_msg_inject_location *ilMsg = (loc_eng_msg_inject_location*) msg;
            loc_eng_data_p->client_handle->injectPosition(ilMsg->latitude, ilMsg->longitude,
                                                          ilMsg->accuracy);
        }
        break;

        case LOC_ENG_MSG_SET_SERVER_IPV4:
        {
            loc_eng_msg_set_server_ipv4 *ssiMsg = (loc_eng_msg_set_server_ipv4*)msg;
            loc_eng_data_p->client_handle->setServer(ssiMsg->nl_addr,
                                                     ssiMsg->port,
                                                     ssiMsg->serverType);
        }
        break;

        case LOC_ENG_MSG_SET_SERVER_URL:
        {
            loc_eng_msg_set_server_url *ssuMsg = (loc_eng_msg_set_server_url*)msg;
            loc_eng_data_p->client_handle->setServer(ssuMsg->url, ssuMsg->len);
        }
        break;

        case LOC_ENG_MSG_SUPL_VERSION:
        {
            loc_eng_msg_suple_version *svMsg = (loc_eng_msg_suple_version*)msg;
            loc_eng_data_p->client_handle->setSUPLVersion(svMsg->supl_version);
        }
        break;

        case LOC_ENG_MSG_LPP_CONFIG:
        {
            loc_eng_msg_lpp_config *svMsg = (loc_eng_msg_lpp_config*)msg;
            loc_eng_data_p->client_handle->setLPPConfig(svMsg->lpp_config);
        }
        break;

        case LOC_ENG_MSG_SET_SENSOR_CONTROL_CONFIG:
        {
            loc_eng_msg_sensor_control_config *sccMsg = (loc_eng_msg_sensor_control_config*)msg;
            loc_eng_data_p->client_handle->setSensorControlConfig(sccMsg->sensorsDisabled);
        }
        break;

        case LOC_ENG_MSG_SET_SENSOR_PROPERTIES:
        {
            loc_eng_msg_sensor_properties *spMsg = (loc_eng_msg_sensor_properties*)msg;
            loc_eng_data_p->client_handle->setSensorProperties(spMsg->gyroBiasVarianceRandomWalk_valid,
                                                               spMsg->gyroBiasVarianceRandomWalk,
                                                               spMsg->accelRandomWalk_valid,
                                                               spMsg->accelRandomWalk,
                                                               spMsg->angleRandomWalk_valid,
                                                               spMsg->angleRandomWalk,
                                                               spMsg->rateRandomWalk_valid,
                                                               spMsg->rateRandomWalk,
                                                               spMsg->velocityRandomWalk_valid,
                                                               spMsg->velocityRandomWalk);
        }
        break;

        case LOC_ENG_MSG_SET_SENSOR_PERF_CONTROL_CONFIG:
        {
            loc_eng_msg_sensor_perf_control_config *spccMsg = (loc_eng_msg_sensor_perf_control_config*)msg;
            loc_eng_data_p->client_handle->setSensorPerfControlConfig(spccMsg->controlMode, spccMsg->accelSamplesPerBatch, spccMsg->accelBatchesPerSec,
                                                                      spccMsg->gyroSamplesPerBatch, spccMsg->gyroBatchesPerSec,
                                                                      spccMsg->accelSamplesPerBatchHigh, spccMsg->accelBatchesPerSecHigh,
                                                                      spccMsg->gyroSamplesPerBatchHigh, spccMsg->gyroBatchesPerSecHigh,
                                                                      spccMsg->algorithmConfig);
        }
        break;

        case LOC_ENG_MSG_EXT_POWER_CONFIG:
        {
            loc_eng_msg_ext_power_config *pwrMsg = (loc_eng_msg_ext_power_config*)msg;
            loc_eng_data_p->client_handle->setExtPowerConfig(pwrMsg->isBatteryCharging);
        }
        break;

        case LOC_ENG_MSG_REPORT_POSITION:
            if (loc_eng_data_p->mute_session_state != LOC_MUTE_SESS_IN_SESSION)
            {
                bool reported = false;
                loc_eng_msg_report_position *rpMsg = (loc_eng_msg_report_position*)msg;
                if (loc_eng_data_p->location_cb != NULL) {
                    if (LOC_SESS_FAILURE == rpMsg->status) {
                        // in case we want to handle the failure case
                        loc_eng_data_p->location_cb(NULL, NULL);
                        reported = true;
                    }
                    // what's in the else if is... (line by line)
                    // 1. this is a good fix; or
                    //   1.1 there is source info; or
                    //   1.1.1 this is from hybrid provider;
                    //   1.2 it is a Satellite fix; or
                    //   1.2.1 it is a sensor fix
                    // 2. (must be intermediate fix... implicit)
                    //   2.1 we accepte intermediate; and
                    //   2.2 it is NOT the case that
                    //   2.2.1 there is inaccuracy; and
                    //   2.2.2 we care about inaccuracy; and
                    //   2.2.3 the inaccuracy exceeds our tolerance
                    else if ((LOC_SESS_SUCCESS == rpMsg->status &&
                              (((LOCATION_HAS_SOURCE_INFO & rpMsg->location.flags) &&
                                ULP_LOCATION_IS_FROM_HYBRID == rpMsg->location.position_source) ||
                               ((LOC_POS_TECH_MASK_SATELLITE & rpMsg->technology_mask) ||
                                (LOC_POS_TECH_MASK_SENSORS & rpMsg->technology_mask)))) ||
                             (LOC_SESS_INTERMEDIATE == loc_eng_data_p->intermediateFix &&
                              !((rpMsg->location.flags & GPS_LOCATION_HAS_ACCURACY) &&
                                (gps_conf.ACCURACY_THRES != 0) &&
                                (rpMsg->location.accuracy > gps_conf.ACCURACY_THRES)))) {
                        loc_eng_data_p->location_cb((GpsLocation*)&(rpMsg->location),
                                                    (void*)rpMsg->locationExt);
                        reported = true;
                    }
                }

                // if we have reported this fix
                if (reported &&
                    // and if this is a singleshot
                    GPS_POSITION_RECURRENCE_SINGLE ==
                    loc_eng_data_p->client_handle->getPositionMode().recurrence) {
                    if (LOC_SESS_INTERMEDIATE == rpMsg->status) {
                        // modem could be still working for a final fix,
                        // although we no longer need it.  So stopFix().
                        loc_eng_data_p->client_handle->stopFix();
                    }
                    // turn off the session flag.
                    loc_eng_data_p->client_handle->setInSession(false);
                }

                if (loc_eng_data_p->generateNmea && rpMsg->location.position_source == ULP_LOCATION_IS_FROM_GNSS)
                {
                    loc_eng_nmea_generate_pos(loc_eng_data_p, rpMsg->location, rpMsg->locationExtended);
                }

                // Free the allocated memory for rawData
                GpsLocation* gp = (GpsLocation*)&(rpMsg->location);
                if (gp != NULL && gp->rawData != NULL)
                {
                    delete (char*)gp->rawData;
                    gp->rawData = NULL;
                    gp->rawDataSize = 0;
                }
            }

            break;

        case LOC_ENG_MSG_REPORT_SV:
            if (loc_eng_data_p->mute_session_state != LOC_MUTE_SESS_IN_SESSION)
            {
                loc_eng_msg_report_sv *rsMsg = (loc_eng_msg_report_sv*)msg;
                if (loc_eng_data_p->sv_status_cb != NULL) {
                    loc_eng_data_p->sv_status_cb((GpsSvStatus*)&(rsMsg->svStatus),
                                                 (void*)rsMsg->svExt);
                }

                if (loc_eng_data_p->generateNmea)
                {
                    loc_eng_nmea_generate_sv(loc_eng_data_p, rsMsg->svStatus, rsMsg->locationExtended);
                }

            }
            break;

        case LOC_ENG_MSG_REPORT_STATUS:
            loc_eng_report_status(*loc_eng_data_p, ((loc_eng_msg_report_status*)msg)->status);
            break;

        case LOC_ENG_MSG_REPORT_NMEA:
            if (NULL != loc_eng_data_p->nmea_cb) {
                loc_eng_msg_report_nmea* nmMsg = (loc_eng_msg_report_nmea*)msg;
                struct timeval tv;
                gettimeofday(&tv, (struct timezone *) NULL);
                int64_t now = tv.tv_sec * 1000LL + tv.tv_usec / 1000;
                CALLBACK_LOG_CALLFLOW("nmea_cb", %p, nmMsg->nmea);
                loc_eng_data_p->nmea_cb(now, nmMsg->nmea, nmMsg->length);
            }
            break;

        case LOC_ENG_MSG_REQUEST_BIT:
        {
            AgpsStateMachine* stateMachine;
            loc_eng_msg_request_bit* brqMsg = (loc_eng_msg_request_bit*)msg;
            if (brqMsg->ifType == LOC_ENG_IF_REQUEST_TYPE_SUPL) {
                stateMachine = loc_eng_data_p->agnss_nif;
            } else if (brqMsg->ifType == LOC_ENG_IF_REQUEST_TYPE_ANY) {
                stateMachine = loc_eng_data_p->internet_nif;
            } else {
                LOC_LOGD("%s]%d: unknown I/F request type = 0x%x\n", __func__, __LINE__, brqMsg->ifType);
                break;
            }
            BITSubscriber subscriber(stateMachine, brqMsg->ipv4Addr, brqMsg->ipv6Addr);

            stateMachine->subscribeRsrc((Subscriber*)&subscriber);
        }
        break;

        case LOC_ENG_MSG_RELEASE_BIT:
        {
            AgpsStateMachine* stateMachine;
            loc_eng_msg_release_bit* brlMsg = (loc_eng_msg_release_bit*)msg;
            if (brlMsg->ifType == LOC_ENG_IF_REQUEST_TYPE_SUPL) {
                stateMachine = loc_eng_data_p->agnss_nif;
            } else if (brlMsg->ifType == LOC_ENG_IF_REQUEST_TYPE_ANY) {
                stateMachine = loc_eng_data_p->internet_nif;
            } else {
                LOC_LOGD("%s]%d: unknown I/F request type = 0x%x\n", __func__, __LINE__, brlMsg->ifType);
                break;
            }
            BITSubscriber subscriber(stateMachine, brlMsg->ipv4Addr, brlMsg->ipv6Addr);

            stateMachine->unsubscribeRsrc((Subscriber*)&subscriber);
        }
        break;

        case LOC_ENG_MSG_REQUEST_ATL:
        {
            loc_eng_msg_request_atl* arqMsg = (loc_eng_msg_request_atl*)msg;
            boolean backwardCompatibleMode = AGPS_TYPE_INVALID == arqMsg->type;
            AgpsStateMachine* stateMachine = (AGPS_TYPE_SUPL == arqMsg->type ||
                                              backwardCompatibleMode) ?
                                             loc_eng_data_p->agnss_nif :
                                             loc_eng_data_p->internet_nif;
            ATLSubscriber subscriber(arqMsg->handle,
                                     stateMachine,
                                     loc_eng_data_p->client_handle,
                                     backwardCompatibleMode);

            stateMachine->subscribeRsrc((Subscriber*)&subscriber);
        }
        break;

        case LOC_ENG_MSG_RELEASE_ATL:
        {
            loc_eng_msg_release_atl* arlMsg = (loc_eng_msg_release_atl*)msg;
            ATLSubscriber s1(arlMsg->handle,
                             loc_eng_data_p->agnss_nif,
                             loc_eng_data_p->client_handle,
                             false);
            // attempt to unsubscribe from agnss_nif first
            if (! loc_eng_data_p->agnss_nif->unsubscribeRsrc((Subscriber*)&s1)) {
                ATLSubscriber s2(arlMsg->handle,
                                 loc_eng_data_p->internet_nif,
                                 loc_eng_data_p->client_handle,
                                 false);
                // if unsuccessful, try internet_nif
                loc_eng_data_p->internet_nif->unsubscribeRsrc((Subscriber*)&s2);
            }
        }
        break;

        case LOC_ENG_MSG_REQUEST_WIFI:
        {
            loc_eng_msg_request_wifi *wrqMsg = (loc_eng_msg_request_wifi *)msg;
            if (wrqMsg->senderId == LOC_ENG_IF_REQUEST_SENDER_ID_QUIPC ||
                wrqMsg->senderId == LOC_ENG_IF_REQUEST_SENDER_ID_MSAPM ||
                wrqMsg->senderId == LOC_ENG_IF_REQUEST_SENDER_ID_MSAPU) {
              AgpsStateMachine* stateMachine = loc_eng_data_p->wifi_nif;
              WIFISubscriber subscriber(stateMachine, wrqMsg->ssid, wrqMsg->password, wrqMsg->senderId);
              stateMachine->subscribeRsrc((Subscriber*)&subscriber);
            } else {
              LOC_LOGE("%s]%d ERROR: unknown sender ID", __func__, __LINE__);
              break;
            }
        }
        break;

        case LOC_ENG_MSG_RELEASE_WIFI:
        {
            AgpsStateMachine* stateMachine = loc_eng_data_p->wifi_nif;
            loc_eng_msg_release_wifi* wrlMsg = (loc_eng_msg_release_wifi*)msg;
            WIFISubscriber subscriber(stateMachine, wrlMsg->ssid, wrlMsg->password, wrlMsg->senderId);
            stateMachine->unsubscribeRsrc((Subscriber*)&subscriber);
        }
        break;

        case LOC_ENG_MSG_REQUEST_XTRA_DATA:
            if (loc_eng_data_p->xtra_module_data.download_request_cb != NULL)
            {
                loc_eng_data_p->xtra_module_data.download_request_cb();
            }
            break;

        case LOC_ENG_MSG_REQUEST_TIME:
            if (loc_eng_data_p->request_utc_time_cb != NULL)
            {
                loc_eng_data_p->request_utc_time_cb();
            }
            else
            {
                LOC_LOGE("%s] ERROR: Callback function for request_time is NULL", __func__);
            }
            break;

        case LOC_ENG_MSG_REQUEST_POSITION:
            break;

        case LOC_ENG_MSG_DELETE_AIDING_DATA:
            loc_eng_data_p->aiding_data_for_deletion |= ((loc_eng_msg_delete_aiding_data*)msg)->type;
            break;

        case LOC_ENG_MSG_ENABLE_DATA:
        {
            loc_eng_msg_set_data_enable *unaMsg = (loc_eng_msg_set_data_enable*)msg;
            loc_eng_data_p->client_handle->enableData(unaMsg->enable);
            loc_eng_data_p->client_handle->setAPN(unaMsg->apn, unaMsg->length);
        }
        break;

        case LOC_ENG_MSG_INJECT_XTRA_DATA:
        {
            loc_eng_msg_inject_xtra_data *xdMsg = (loc_eng_msg_inject_xtra_data*)msg;
            loc_eng_data_p->client_handle->setXtraData(xdMsg->data, xdMsg->length);
        }
        break;

        case LOC_ENG_MSG_ATL_OPEN_SUCCESS:
        {
            loc_eng_msg_atl_open_success *aosMsg = (loc_eng_msg_atl_open_success*)msg;
            AgpsStateMachine* stateMachine;
            switch (aosMsg->agpsType) {
              case AGPS_TYPE_WIFI: {
                stateMachine = loc_eng_data_p->wifi_nif;
                break;
              }
              case AGPS_TYPE_SUPL: {
                stateMachine = loc_eng_data_p->agnss_nif;
                break;
              }
              default: {
                stateMachine  = loc_eng_data_p->internet_nif;
              }
            }

            stateMachine->setBearer(aosMsg->bearerType);
            stateMachine->setAPN(aosMsg->apn, aosMsg->length);
            stateMachine->onRsrcEvent(RSRC_GRANTED);
        }
        break;

        case LOC_ENG_MSG_ATL_CLOSED:
        {
            loc_eng_msg_atl_closed *acsMsg = (loc_eng_msg_atl_closed*)msg;
            AgpsStateMachine* stateMachine;
            switch (acsMsg->agpsType) {
              case AGPS_TYPE_WIFI: {
                stateMachine = loc_eng_data_p->wifi_nif;
                break;
              }
              case AGPS_TYPE_SUPL: {
                stateMachine = loc_eng_data_p->agnss_nif;
                break;
              }
              default: {
                stateMachine  = loc_eng_data_p->internet_nif;
              }
            }

            stateMachine->onRsrcEvent(RSRC_RELEASED);
        }
        break;

        case LOC_ENG_MSG_ATL_OPEN_FAILED:
        {
            loc_eng_msg_atl_open_failed *aofMsg = (loc_eng_msg_atl_open_failed*)msg;
            AgpsStateMachine* stateMachine;
            switch (aofMsg->agpsType) {
              case AGPS_TYPE_WIFI: {
                stateMachine = loc_eng_data_p->wifi_nif;
                break;
              }
              case AGPS_TYPE_SUPL: {
                stateMachine = loc_eng_data_p->agnss_nif;
                break;
              }
              default: {
                stateMachine  = loc_eng_data_p->internet_nif;
              }
            }

            stateMachine->onRsrcEvent(RSRC_DENIED);
        }
        break;

        case LOC_ENG_MSG_ENGINE_DOWN:
            loc_eng_handle_engine_down(*loc_eng_data_p);
            break;

        case LOC_ENG_MSG_ENGINE_UP:
            loc_eng_handle_engine_up(*loc_eng_data_p);
            break;

        case LOC_ENG_MSG_REQUEST_NETWORK_POSIITON:
        {
            loc_eng_msg_request_network_position *nlprequestmsg = (loc_eng_msg_request_network_position*)msg;
            //loc_eng_handle_request_network_position(nlprequestmsg );
            LOC_LOGD("Received n/w position request from ULP.Request type %d Periodicity: %d\n",
                     nlprequestmsg->networkPosRequest.request_type,
                      nlprequestmsg->networkPosRequest.interval_ms);
            if(loc_eng_data_p->ulp_network_callback != NULL)
            {
                loc_eng_data_p->ulp_network_callback((UlpNetworkRequestPos*)&(nlprequestmsg->networkPosRequest));
            }
            else
                LOC_LOGE("Ulp Network call back not initialized");
        }
        break;

        case LOC_ENG_MSG_REQUEST_PHONE_CONTEXT:
        {
            loc_eng_msg_request_phone_context *contextReqMsg = (loc_eng_msg_request_phone_context*)msg;
            LOC_LOGD("Received phone context request from ULP.context_type 0x%x,request_type 0x%x  ",
                     contextReqMsg->contextRequest.context_type,contextReqMsg->contextRequest.request_type)
            if(loc_eng_data_p->ulp_phone_context_req_cb != NULL)
            {
                loc_eng_data_p->ulp_phone_context_req_cb((UlpPhoneContextRequest*)&(contextReqMsg->contextRequest));
            }
            else
                LOC_LOGE("Ulp Phone context request call back not initialized");
            }
        break;

        case LOC_ENG_MSG_PRIVACY:
        {
            loc_eng_msg_privacy *privacyMsg = (loc_eng_msg_privacy*)msg;
#ifdef SET_PRIVACY
            loc_eng_data_p->client_handle->setPrivacy(privacyMsg->privacy_setting);
#else
            LOC_LOGE("Ignoring call to setPrivacy");
#endif
        }
        break;

        default:
            LOC_LOGE("unsupported msgid = %d\n", msg->msgid);
            break;
        }

        if ( (msg->msgid == LOC_ENG_MSG_ATL_OPEN_FAILED)  |
             (msg->msgid == LOC_ENG_MSG_ATL_CLOSED)  |
             (msg->msgid == LOC_ENG_MSG_ATL_OPEN_SUCCESS) )
        {
            loc_eng_data_p->agps_request_pending = false;
            if (loc_eng_data_p->stop_request_pending) {
                loc_eng_stop_handler(*loc_eng_data_p);
                loc_eng_data_p->stop_request_pending = false;
            }
        }
        loc_eng_data_p->stop_request_pending = false;

        if (loc_eng_data_p->engine_status != GPS_STATUS_ENGINE_ON &&
            loc_eng_data_p->aiding_data_for_deletion != 0)
        {
            loc_eng_data_p->client_handle->deleteAidingData(loc_eng_data_p->aiding_data_for_deletion);
            loc_eng_data_p->aiding_data_for_deletion = 0;
        }

        delete msg;
    }

    EXIT_LOG(%s, VOID_RET);
}

/*===========================================================================
FUNCTION loc_eng_ulp_init

DESCRIPTION
   This function dynamically loads the libulp.so and calls
   its init function to start up the ulp module

DEPENDENCIES
   None

RETURN VALUE
   0: no error
   -1: errors

SIDE EFFECTS
   N/A

===========================================================================*/
int loc_eng_ulp_init(loc_eng_data_s_type &loc_eng_data, const ulpInterface * loc_eng_ulpInf)
{
    ENTRY_LOG();
    int ret_val=-1;
    if((loc_eng_ulpInf != NULL) && (((ulpInterface *)loc_eng_ulpInf)->init != NULL))
    {
        // Initialize the ULP interface
        ((ulpInterface *)loc_eng_ulpInf)->init(loc_eng_data);
        loc_eng_data.ulp_initialized = TRUE;
        ret_val = 0;
    }
    else
        LOC_LOGE("ulp not initialized. NULL parameter");
    EXIT_LOG(%d, ret_val);
    return ret_val;
}

/*===========================================================================
FUNCTION    loc_eng_inject_raw_command

DESCRIPTION
   This is used to send special test modem commands from the applications
   down into the HAL
DEPENDENCIES
   N/A

RETURN VALUE
   0: success

SIDE EFFECTS
   N/A

===========================================================================*/
bool loc_eng_inject_raw_command(loc_eng_data_s_type &loc_eng_data,
                                char* command, int length)
{
    ENTRY_LOG_CALLFLOW();
    INIT_CHECK(loc_eng_data.context, return -1);
    boolean ret_val;
    LOC_LOGD("loc_eng_send_extra_command: %s\n", command);
    ret_val = TRUE;

    if((loc_eng_data.ulp_initialized == true) && (gps_conf.CAPABILITIES & ULP_CAPABILITY))
    {
        ulp_msg_inject_raw_command *msg(
            new ulp_msg_inject_raw_command(&loc_eng_data,command, length));
        msg_q_snd( (void*)((LocEngContext*)(loc_eng_data.context))->ulp_q
                   , msg, loc_eng_free_msg);
        ret_val = 0;
    }else
    {
        ret_val = -1;
    }


    EXIT_LOG(%s, loc_logger_boolStr[ret_val!=0]);
    return ret_val;
}
/*===========================================================================
FUNCTION    loc_eng_update_criteria

DESCRIPTION
   This is used to inform the ULP module of new unique criteria that are passed
   in by the applications
DEPENDENCIES
   N/A

RETURN VALUE
   0: success

SIDE EFFECTS
   N/A

===========================================================================*/
int loc_eng_update_criteria(loc_eng_data_s_type &loc_eng_data,
                            UlpLocationCriteria criteria)
{
    ENTRY_LOG_CALLFLOW();
    INIT_CHECK(loc_eng_data.context, return -1);
    int ret_val;

    if((loc_eng_data.ulp_initialized == true) && (gps_conf.CAPABILITIES & ULP_CAPABILITY))
    {
       LOC_LOGD("SJ:loc_eng_update_criteria: valid 0x%x action:%d, minTime:%ld, minDistance:%f, singleShot:%d, horizontalAccuracy:%d, powerRequirement:%d \n",
         criteria.valid_mask, criteria.action, criteria.min_interval, criteria.min_distance,  criteria.recurrence_type,  criteria.preferred_horizontal_accuracy,
              criteria.preferred_power_consumption );
     ulp_msg_update_criteria *msg(
         new ulp_msg_update_criteria(&loc_eng_data,criteria));
     msg_q_snd( (void*)((LocEngContext*)(loc_eng_data.context))->ulp_q
                , msg, loc_eng_free_msg);
     ret_val = 0;
    }else
    {
        ret_val = -1;
    }
    EXIT_LOG(%d, ret_val);
    return ret_val;
}

/*===========================================================================
FUNCTION    loc_eng_ulp_phone_context_settings_update

DESCRIPTION
   This is used to inform the ULP module of phone settings changes carried out
   by the users
DEPENDENCIES
   N/A

RETURN VALUE
   0: success

SIDE EFFECTS
   N/A

===========================================================================*/

int loc_eng_ulp_phone_context_settings_update(loc_eng_data_s_type &loc_eng_data,
                                              UlpPhoneContextSettings *settings)
{
    ENTRY_LOG();
    int ret_val = -1;

    LOC_LOGD("loc_eng_ulp_phone_context_settings: context_type - 0x%x is_agps_enabled - %d "
             "is_battery_charging %d ,is_gps_enabled %d, is_network_position_available %d,"
             "is_wifi_setting_enabled %d, is_agps_setting_enabled %d, is_enh_location_services_enabled %d\n",
             settings->context_type ,settings->is_agps_enabled,settings->is_battery_charging,
             settings->is_gps_enabled, settings->is_network_position_available,
             settings->is_wifi_setting_enabled, settings->is_agps_enabled,
             settings->is_enh_location_services_enabled );

    if((loc_eng_data.ulp_initialized == true) && (gps_conf.CAPABILITIES & ULP_CAPABILITY))
    {
        ulp_msg_inject_phone_context_settings *msg
         (new ulp_msg_inject_phone_context_settings(&loc_eng_data, *settings));
        msg_q_snd( (void*)((LocEngContext*)(loc_eng_data.context))->ulp_q, msg, loc_eng_free_msg);
        ret_val = 0;
    }

    // Send battery information to modem for processing.
    if(settings->context_type & ULP_PHONE_CONTEXT_BATTERY_CHARGING_STATE)
    {
        loc_eng_msg_ext_power_config *msg(new loc_eng_msg_ext_power_config(&loc_eng_data, settings->is_battery_charging));
        msg_q_snd( (void*)((LocEngContext*)(loc_eng_data.context))->deferred_q, msg, loc_eng_free_msg);
    }

    EXIT_LOG(%d, ret_val);
    return ret_val;
}
/*===========================================================================
FUNCTION    loc_eng_ulp_network_init

DESCRIPTION
   Initialize the ULP network interface.

DEPENDENCIES
   NONE

RETURN VALUE
   0

SIDE EFFECTS
   N/A

===========================================================================*/
int loc_eng_ulp_phone_context_init(loc_eng_data_s_type &loc_eng_data,UlpPhoneContextCallbacks *callback)
{
    int ret_val = -1;
    ENTRY_LOG();
    if(callback != NULL) {
        loc_eng_data.ulp_phone_context_req_cb = callback->ulp_request_phone_context_cb ;
        ret_val = 0;
    }
    else
        LOC_LOGE("loc_eng_ulp_phone_context_init: bad parameters cb %p", callback);
    EXIT_LOG(%d, ret_val);
    return ret_val;
}

/*===========================================================================
FUNCTION    loc_eng_ulp_network_init

DESCRIPTION
   Initialize the ULP network interface.

DEPENDENCIES
   NONE

RETURN VALUE
   0

SIDE EFFECTS
   N/A

===========================================================================*/
int loc_eng_ulp_network_init(loc_eng_data_s_type &loc_eng_data,
                             UlpNetworkLocationCallbacks *callbacks)
{
    int ret_val = -1;
    ENTRY_LOG_CALLFLOW();
    if(callbacks != NULL) {
        loc_eng_data.ulp_network_callback = callbacks->ulp_network_location_request_cb;
        ret_val = 0;
    }
    else
        LOC_LOGE("loc_eng_ulp_network_init: bad parameters cb %p", callbacks);
    EXIT_LOG(%d, ret_val);
    return ret_val;
}


/*===========================================================================
FUNCTION    loc_eng_ulp_send_network_position

DESCRIPTION
   Ulp send data

DEPENDENCIES
   NONE

RETURN VALUE
   0

SIDE EFFECTS
   N/A

===========================================================================*/
int loc_eng_ulp_send_network_position(loc_eng_data_s_type &loc_eng_data,
                                             UlpNetworkPositionReport *position_report)
{
    ENTRY_LOG();
    int ret_val = 0;
    if((loc_eng_data.ulp_initialized == true) && (gps_conf.CAPABILITIES & ULP_CAPABILITY))
    {
     ulp_msg_inject_network_position *msg
         (new ulp_msg_inject_network_position(&loc_eng_data, *position_report));
     msg_q_snd( (void*)((LocEngContext*)(loc_eng_data.context))->ulp_q
                , msg, loc_eng_free_msg);
     ret_val = 0;
    }else
    {
        ret_val = -1;
    }
    EXIT_LOG(%d, ret_val);
    return ret_val;
}
/*===========================================================================
FUNCTION    loc_eng_read_config

DESCRIPTION
   Initiates the reading of the gps config file stored in /etc dir

DEPENDENCIES
   None

RETURN VALUE
   0: success

SIDE EFFECTS
   N/A

===========================================================================*/
int loc_eng_read_config(void)
{
    ENTRY_LOG_CALLFLOW();
    if(gpsConfigAlreadyRead == false)
    {
      // Initialize our defaults before reading of configuration file overwrites them.
      loc_default_parameters();
      // Ee only want to parse the conf file once. This is a good place to ensure that.
      // In fact one day the conf file should go into context.
      UTIL_READ_CONF(GPS_CONF_FILE, loc_parameter_table);
      gpsConfigAlreadyRead = true;
    } else {
      LOC_LOGV("GPS Config file has already been read\n");
    }

    EXIT_LOG(%d, 0);
    return 0;
}

/*===========================================================================
FUNCTION    loc_eng_set_privacy

DESCRIPTION
   Sets the privacy lock setting (1. GPS on, 0. GPS off).

DEPENDENCIES
   None

RETURN VALUE
   0: success

SIDE EFFECTS
   N/A

===========================================================================*/
static int loc_eng_set_privacy(loc_eng_data_s_type &loc_eng_data,
                               int8_t privacy_setting)
{
    ENTRY_LOG();
    INIT_CHECK(loc_eng_data.context, return -1);
#ifdef SET_PRIVACY
    loc_eng_msg_privacy *msg(
        new loc_eng_msg_privacy(&loc_eng_data, privacy_setting));
    msg_q_snd((void*)((LocEngContext*)(loc_eng_data.context))->deferred_q,
              msg, loc_eng_free_msg);
#endif
    EXIT_LOG(%d, 0);
    return 0;
}