update gps hal from jf

Change-Id: I8d08e1c871d9b9e4338f4823c8cdd1d33f6a2b6b

1 files changed, 0 insertions, 904 deletions

diff --git a/gps/libloc_api_50001/loc_eng_msg.h b/gps/libloc_api_50001/loc_eng_msg.h
deleted file mode 100755
index 0728653..0000000
--- a/gps/libloc_api_50001/loc_eng_msg.h
+++ /dev/null
@@ -1,904 +0,0 @@
-/* Copyright (c) 2011-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.
- *
- */
-#ifndef LOC_ENG_MSG_H
-#define LOC_ENG_MSG_H
-
-
-#include <hardware/gps.h>
-#include <stdlib.h>
-#include <string.h>
-#include "log_util.h"
-#include "loc.h"
-#include <loc_eng_log.h>
-#include "loc_eng_msg_id.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif /* __cplusplus */
-
-struct LocPosMode
-{
-    LocPositionMode mode;
-    GpsPositionRecurrence recurrence;
-    uint32_t min_interval;
-    uint32_t preferred_accuracy;
-    uint32_t preferred_time;
-    char credentials[14];
-    char provider[8];
-    LocPosMode(LocPositionMode m, GpsPositionRecurrence recr,
-               uint32_t gap, uint32_t accu, uint32_t time,
-               const char* cred, const char* prov) :
-        mode(m), recurrence(recr),
-        min_interval(gap < MIN_POSSIBLE_FIX_INTERVAL ? MIN_POSSIBLE_FIX_INTERVAL : gap),
-        preferred_accuracy(accu), preferred_time(time) {
-        memset(credentials, 0, sizeof(credentials));
-        memset(provider, 0, sizeof(provider));
-        if (NULL != cred) {
-            memcpy(credentials, cred, sizeof(credentials)-1);
-        }
-        if (NULL != prov) {
-            memcpy(provider, prov, sizeof(provider)-1);
-        }
-    }
-
-    LocPosMode() :
-        mode(LOC_POSITION_MODE_MS_BASED), recurrence(GPS_POSITION_RECURRENCE_PERIODIC),
-        min_interval(MIN_POSSIBLE_FIX_INTERVAL), preferred_accuracy(50), preferred_time(120000) {
-        memset(credentials, 0, sizeof(credentials));
-        memset(provider, 0, sizeof(provider));
-    }
-
-    inline bool equals(const LocPosMode &anotherMode) const
-    {
-        return anotherMode.mode == mode &&
-            anotherMode.recurrence == recurrence &&
-            anotherMode.min_interval == min_interval &&
-            anotherMode.preferred_accuracy == preferred_accuracy &&
-            anotherMode.preferred_time == preferred_time &&
-            !strncmp(anotherMode.credentials, credentials, sizeof(credentials)-1) &&
-            !strncmp(anotherMode.provider, provider, sizeof(provider)-1);
-    }
-
-    inline void logv() const
-    {
-        LOC_LOGV ("Position mode: %s\n  Position recurrence: %s\n  min interval: %d\n  preferred accuracy: %d\n  preferred time: %d\n  credentials: %s  provider: %s",
-                  loc_get_position_mode_name(mode),
-                  loc_get_position_recurrence_name(recurrence),
-                  min_interval,
-                  preferred_accuracy,
-                  preferred_time,
-                  credentials,
-                  provider);
-    }
-};
-
-/** Flags to indicate which values are valid in a GpsLocationExtended. */
-typedef uint16_t GpsLocationExtendedFlags;
-/** GpsLocationExtended has valid pdop, hdop, vdop. */
-#define GPS_LOCATION_EXTENDED_HAS_DOP 0x0001
-/** GpsLocationExtended has valid altitude mean sea level. */
-#define GPS_LOCATION_EXTENDED_HAS_ALTITUDE_MEAN_SEA_LEVEL 0x0002
-/** GpsLocation has valid magnetic deviation. */
-#define GPS_LOCATION_EXTENDED_HAS_MAG_DEV 0x0004
-/** GpsLocation has valid mode indicator. */
-#define GPS_LOCATION_EXTENDED_HAS_MODE_IND 0x0008
-
-/** Represents gps location extended. */
-typedef struct {
-    /** set to sizeof(GpsLocationExtended) */
-    size_t          size;
-    /** Contains GpsLocationExtendedFlags bits. */
-    uint16_t        flags;
-    /** Contains the Altitude wrt mean sea level */
-    float           altitudeMeanSeaLevel;
-    /** Contains Position Dilusion of Precision. */
-    float           pdop;
-    /** Contains Horizontal Dilusion of Precision. */
-    float           hdop;
-    /** Contains Vertical Dilusion of Precision. */
-    float           vdop;
-    /** Contains Magnetic Deviation. */
-    float           magneticDeviation;
-} GpsLocationExtended;
-
-typedef enum {
-  LOC_ENG_IF_REQUEST_TYPE_SUPL = 0,
-  LOC_ENG_IF_REQUEST_TYPE_WIFI,
-  LOC_ENG_IF_REQUEST_TYPE_ANY
-} loc_if_req_type_e_type;
-
-typedef enum {
-  LOC_ENG_IF_REQUEST_SENDER_ID_QUIPC = 0,
-  LOC_ENG_IF_REQUEST_SENDER_ID_MSAPM,
-  LOC_ENG_IF_REQUEST_SENDER_ID_MSAPU,
-  LOC_ENG_IF_REQUEST_SENDER_ID_GPSONE_DAEMON,
-  LOC_ENG_IF_REQUEST_SENDER_ID_MODEM,
-  LOC_ENG_IF_REQUEST_SENDER_ID_UNKNOWN
-} loc_if_req_sender_id_e_type;
-
-struct loc_eng_msg {
-    const void* owner;
-    const int msgid;
-    inline loc_eng_msg(void* instance, int id) :
-        owner(instance), msgid(id)
-    {
-        LOC_LOGV("creating msg %s", loc_get_msg_name(msgid));
-        LOC_LOGV("creating msg ox%x", msgid);
-    }
-    virtual ~loc_eng_msg()
-    {
-        LOC_LOGV("deleting msg %s", loc_get_msg_name(msgid));
-        LOC_LOGV("deleting msg ox%x", msgid);
-    }
-};
-
-struct loc_eng_msg_suple_version : public loc_eng_msg {
-    const int supl_version;
-    inline loc_eng_msg_suple_version(void* instance, int version) :
-        loc_eng_msg(instance, LOC_ENG_MSG_SUPL_VERSION),
-        supl_version(version)
-        {
-            LOC_LOGV("SUPL Version: %d", version);
-        }
-};
-
-struct loc_eng_msg_lpp_config : public loc_eng_msg {
-    const int lpp_config;
-    inline loc_eng_msg_lpp_config(void *instance, int profile) :
-        loc_eng_msg(instance, LOC_ENG_MSG_LPP_CONFIG),
-        lpp_config(profile)
-        {
-            LOC_LOGV("lpp profile: %d", profile);
-        }
-};
-
-struct loc_eng_msg_ext_power_config : public loc_eng_msg {
-    const int isBatteryCharging;
-    inline loc_eng_msg_ext_power_config(void* instance, int isBattCharging) :
-            loc_eng_msg(instance, LOC_ENG_MSG_EXT_POWER_CONFIG),
-            isBatteryCharging(isBattCharging)
-        {
-            LOC_LOGV("isBatteryCharging: %d", isBatteryCharging);
-        }
-};
-
-struct loc_eng_msg_sensor_control_config : public loc_eng_msg {
-    const int sensorsDisabled;
-    inline loc_eng_msg_sensor_control_config(void* instance, int disabled) :
-            loc_eng_msg(instance, LOC_ENG_MSG_SET_SENSOR_CONTROL_CONFIG),
-            sensorsDisabled(disabled)
-        {
-            LOC_LOGV("Sensors Disabled: %d", disabled);
-        }
-};
-
-struct loc_eng_msg_sensor_properties : public loc_eng_msg {
-    const bool gyroBiasVarianceRandomWalk_valid;
-    const float gyroBiasVarianceRandomWalk;
-    const bool accelRandomWalk_valid;
-    const float accelRandomWalk;
-    const bool angleRandomWalk_valid;
-    const float angleRandomWalk;
-    const bool rateRandomWalk_valid;
-    const float rateRandomWalk;
-    const bool velocityRandomWalk_valid;
-    const float velocityRandomWalk;
-    inline loc_eng_msg_sensor_properties(void* instance, bool gyroBiasRandomWalk_valid, float gyroBiasRandomWalk,
-                                          bool accelRandomWalk_valid, float accelRandomWalk,
-                                          bool angleRandomWalk_valid, float angleRandomWalk,
-                                          bool rateRandomWalk_valid, float rateRandomWalk,
-                                          bool velocityRandomWalk_valid, float velocityRandomWalk) :
-            loc_eng_msg(instance, LOC_ENG_MSG_SET_SENSOR_PROPERTIES),
-            gyroBiasVarianceRandomWalk_valid(gyroBiasRandomWalk_valid),
-            gyroBiasVarianceRandomWalk(gyroBiasRandomWalk),
-            accelRandomWalk_valid(accelRandomWalk_valid),
-            accelRandomWalk(accelRandomWalk),
-            angleRandomWalk_valid(angleRandomWalk_valid),
-            angleRandomWalk(angleRandomWalk),
-            rateRandomWalk_valid(rateRandomWalk_valid),
-            rateRandomWalk(rateRandomWalk),
-            velocityRandomWalk_valid(velocityRandomWalk_valid),
-            velocityRandomWalk(velocityRandomWalk)
-        {
-            LOC_LOGV("Sensor properties validity, Gyro Random walk: %d Accel Random Walk: %d "
-                     "Angle Random Walk: %d Rate Random Walk: %d "
-                     "Velocity Random Walk: %d",
-                     gyroBiasRandomWalk_valid,
-                     accelRandomWalk_valid,
-                     angleRandomWalk_valid,
-                     rateRandomWalk_valid,
-                     velocityRandomWalk_valid
-                     );
-            LOC_LOGV("Sensor properties, Gyro Random walk: %f Accel Random Walk: %f "
-                     "Angle Random Walk: %f Rate Random Walk: %f "
-                     "Velocity Random Walk: %f",
-                     gyroBiasRandomWalk,
-                     accelRandomWalk,
-                     angleRandomWalk,
-                     rateRandomWalk,
-                     velocityRandomWalk
-                     );
-        }
-};
-
-struct loc_eng_msg_sensor_perf_control_config : public loc_eng_msg {
-    const int controlMode;
-    const int accelSamplesPerBatch;
-    const int accelBatchesPerSec;
-    const int gyroSamplesPerBatch;
-    const int gyroBatchesPerSec;
-    const int accelSamplesPerBatchHigh;
-    const int accelBatchesPerSecHigh;
-    const int gyroSamplesPerBatchHigh;
-    const int gyroBatchesPerSecHigh;
-    const int algorithmConfig;
-    inline loc_eng_msg_sensor_perf_control_config(void* instance, int controlMode,
-                                                  int accelSamplesPerBatch, int accelBatchesPerSec,
-                                                  int gyroSamplesPerBatch, int gyroBatchesPerSec,
-                                                  int accelSamplesPerBatchHigh, int accelBatchesPerSecHigh,
-                                                  int gyroSamplesPerBatchHigh, int gyroBatchesPerSecHigh,
-                                                  int algorithmConfig) :
-            loc_eng_msg(instance, LOC_ENG_MSG_SET_SENSOR_PERF_CONTROL_CONFIG),
-            controlMode(controlMode),
-            accelSamplesPerBatch(accelSamplesPerBatch),
-            accelBatchesPerSec(accelBatchesPerSec),
-            gyroSamplesPerBatch(gyroSamplesPerBatch),
-            gyroBatchesPerSec(gyroBatchesPerSec),
-            accelSamplesPerBatchHigh(accelSamplesPerBatchHigh),
-            accelBatchesPerSecHigh(accelBatchesPerSecHigh),
-            gyroSamplesPerBatchHigh(gyroSamplesPerBatchHigh),
-            gyroBatchesPerSecHigh(gyroBatchesPerSecHigh),
-            algorithmConfig(algorithmConfig)
-        {
-            LOC_LOGV("Sensor Perf Control Config (performanceControlMode)(%u) "
-                "accel(#smp,#batches) (%u,%u) gyro(#smp,#batches) (%u,%u), "
-                "accel_high(#smp,#batches) (%u,%u) gyro_high(#smp,#batches) (%u,%u), "
-                "algorithmConfig(%u)\n",
-                controlMode,
-                accelSamplesPerBatch,
-                accelBatchesPerSec,
-                gyroSamplesPerBatch,
-                gyroBatchesPerSec,
-                accelSamplesPerBatchHigh,
-                accelBatchesPerSecHigh,
-                gyroSamplesPerBatchHigh,
-                gyroBatchesPerSecHigh,
-                algorithmConfig
-                );
-        }
-};
-
-
-struct loc_eng_msg_position_mode : public loc_eng_msg {
-    const LocPosMode pMode;
-    inline loc_eng_msg_position_mode(void* instance,
-                                     LocPosMode &mode) :
-        loc_eng_msg(instance, LOC_ENG_MSG_SET_POSITION_MODE),
-        pMode(mode)
-    {
-        pMode.logv();
-    }
-};
-
-struct loc_eng_msg_set_time : public loc_eng_msg {
-    const GpsUtcTime time;
-    const int64_t timeReference;
-    const int uncertainty;
-    inline loc_eng_msg_set_time(void* instance,
-                                GpsUtcTime t,
-                                int64_t tf,
-                                int unc) :
-        loc_eng_msg(instance, LOC_ENG_MSG_SET_TIME),
-        time(t), timeReference(tf), uncertainty(unc)
-    {
-        LOC_LOGV("time: %lld\n  timeReference: %lld\n  uncertainty: %d",
-                 time, timeReference, uncertainty);
-    }
-};
-
-struct loc_eng_msg_inject_location : public loc_eng_msg {
-    const double latitude;
-    const double longitude;
-    const float accuracy;
-    inline loc_eng_msg_inject_location(void* instance, double lat,
-                                       double longi, float accur) :
-        loc_eng_msg(instance, LOC_ENG_MSG_INJECT_LOCATION),
-        latitude(lat), longitude(longi), accuracy(accur)
-    {
-        LOC_LOGV("latitude: %f\n  longitude: %f\n  accuracy: %f",
-                 latitude, longitude, accuracy);
-    }
-};
-
-struct loc_eng_msg_delete_aiding_data : public loc_eng_msg {
-    const GpsAidingData type;
-    inline loc_eng_msg_delete_aiding_data(void* instance, GpsAidingData data) :
-        loc_eng_msg(instance, LOC_ENG_MSG_DELETE_AIDING_DATA), type(data)
-    {
-        LOC_LOGV("aiding data msak %d", type);
-    }
-};
-
-struct loc_eng_msg_report_position : public loc_eng_msg {
-    const GpsLocation location;
-    const GpsLocationExtended locationExtended;
-    const void* locationExt;
-    const enum loc_sess_status status;
-    const LocPosTechMask technology_mask;
-    inline loc_eng_msg_report_position(void* instance, GpsLocation &loc, GpsLocationExtended &locExtended, void* locExt,
-                                       enum loc_sess_status st) :
-        loc_eng_msg(instance, LOC_ENG_MSG_REPORT_POSITION),
-        location(loc), locationExtended(locExtended), locationExt(locExt), status(st), technology_mask(LOC_POS_TECH_MASK_DEFAULT)
-    {
-        LOC_LOGV("flags: %d\n  source: %d\n  latitude: %f\n  longitude: %f\n  altitude: %f\n  speed: %f\n  bearing: %f\n  accuracy: %f\n  timestamp: %lld\n  rawDataSize: %d\n  rawData: %p\n  Session status: %d\n Technology mask: %u",
-                 location.flags, location.position_source, location.latitude, location.longitude,
-                 location.altitude, location.speed, location.bearing, location.accuracy,
-                 location.timestamp, location.rawDataSize, location.rawData,status,technology_mask);
-    }
-    inline loc_eng_msg_report_position(void* instance, GpsLocation &loc, GpsLocationExtended &locExtended, void* locExt,
-                                       enum loc_sess_status st, LocPosTechMask technology) :
-        loc_eng_msg(instance, LOC_ENG_MSG_REPORT_POSITION),
-        location(loc), locationExtended(locExtended), locationExt(locExt), status(st), technology_mask(technology)
-    {
-        LOC_LOGV("flags: %d\n  source: %d\n  latitude: %f\n  longitude: %f\n  altitude: %f\n  speed: %f\n  bearing: %f\n  accuracy: %f\n  timestamp: %lld\n  rawDataSize: %d\n  rawData: %p\n  Session status: %d\n Technology mask: %u",
-                 location.flags, location.position_source, location.latitude, location.longitude,
-                 location.altitude, location.speed, location.bearing, location.accuracy,
-                 location.timestamp, location.rawDataSize, location.rawData,status,technology_mask);
-    }
-};
-
-struct loc_eng_msg_report_sv : public loc_eng_msg {
-    const GpsSvStatus svStatus;
-    const GpsLocationExtended locationExtended;
-    const void* svExt;
-    inline loc_eng_msg_report_sv(void* instance, GpsSvStatus &sv, GpsLocationExtended &locExtended, void* ext) :
-        loc_eng_msg(instance, LOC_ENG_MSG_REPORT_SV), svStatus(sv), locationExtended(locExtended), svExt(ext)
-    {
-        LOC_LOGV("num sv: %d\n  ephemeris mask: %dxn  almanac mask: %x\n  used in fix mask: %x\n      sv: prn         snr       elevation      azimuth",
-                 svStatus.num_svs, svStatus.ephemeris_mask, svStatus.almanac_mask, svStatus.used_in_fix_mask);
-        for (int i = 0; i < svStatus.num_svs && i < GPS_MAX_SVS; i++) {
-            LOC_LOGV("   %d:   %d    %f    %f    %f\n  ",
-                     i,
-                     svStatus.sv_list[i].prn,
-                     svStatus.sv_list[i].snr,
-                     svStatus.sv_list[i].elevation,
-                     svStatus.sv_list[i].azimuth);
-        }
-    }
-};
-
-struct loc_eng_msg_report_status : public loc_eng_msg {
-    const GpsStatusValue status;
-    inline loc_eng_msg_report_status(void* instance, GpsStatusValue engineStatus) :
-        loc_eng_msg(instance, LOC_ENG_MSG_REPORT_STATUS), status(engineStatus)
-    {
-        LOC_LOGV("status: %s", loc_get_gps_status_name(status));
-    }
-};
-
-struct loc_eng_msg_report_nmea : public loc_eng_msg {
-    char* const nmea;
-    const int length;
-    inline loc_eng_msg_report_nmea(void* instance,
-                                   const char* data,
-                                   int len) :
-        loc_eng_msg(instance, LOC_ENG_MSG_REPORT_NMEA),
-        nmea(new char[len]), length(len)
-    {
-        memcpy((void*)nmea, (void*)data, len);
-        LOC_LOGV("length: %d\n  nmea: %p - %c%c%c",
-                 length, nmea, nmea[3], nmea[4], nmea[5]);
-    }
-    inline ~loc_eng_msg_report_nmea()
-    {
-        delete[] nmea;
-    }
-};
-
-struct loc_eng_msg_request_bit : public loc_eng_msg {
-    const loc_if_req_type_e_type ifType;
-    const int ipv4Addr;
-    char* const ipv6Addr;
-    inline loc_eng_msg_request_bit(void* instance,
-                                   loc_if_req_type_e_type type,
-                                   int ipv4,
-                                   char* ipv6) :
-        loc_eng_msg(instance, LOC_ENG_MSG_REQUEST_BIT),
-        ifType(type), ipv4Addr(ipv4),
-        ipv6Addr(NULL == ipv6 ? NULL : new char[16])
-    {
-        if (NULL != ipv6Addr)
-            memcpy(ipv6Addr, ipv6, 16);
-        LOC_LOGV("ifType: %d, ipv4: %d.%d.%d.%d, ipv6: %s", ifType,
-                 (unsigned char)(ipv4>>24),
-                 (unsigned char)(ipv4>>16),
-                 (unsigned char)(ipv4>>8),
-                 (unsigned char)ipv4,
-                 NULL != ipv6Addr ? ipv6Addr : "");
-    }
-
-    inline ~loc_eng_msg_request_bit()
-    {
-        if (NULL != ipv6Addr) {
-            delete[] ipv6Addr;
-        }
-    }
-};
-
-struct loc_eng_msg_request_wifi : public loc_eng_msg {
-    const loc_if_req_type_e_type ifType;
-    const loc_if_req_sender_id_e_type senderId;
-    char* const ssid;
-    char* const password;
-    inline loc_eng_msg_request_wifi(void* instance,
-                                   loc_if_req_type_e_type type,
-                                   loc_if_req_sender_id_e_type sender_id,
-                                   char* s,
-                                   char* p) :
-        loc_eng_msg(instance, LOC_ENG_MSG_REQUEST_WIFI),
-        ifType(type), senderId(sender_id),
-        ssid(NULL == s ? NULL : new char[SSID_BUF_SIZE]),
-        password(NULL == p ? NULL : new char[SSID_BUF_SIZE])
-    {
-        if (NULL != ssid)
-            strlcpy(ssid, s, SSID_BUF_SIZE);
-        if (NULL != password)
-            strlcpy(password, p, SSID_BUF_SIZE);
-        LOC_LOGV("ifType: %d, senderId: %d, ssid: %s, password: %s",
-                 ifType,
-                 senderId,
-                 NULL != ssid ? ssid : "",
-                 NULL != password ? password : "");
-    }
-
-    inline ~loc_eng_msg_request_wifi()
-    {
-        if (NULL != ssid) {
-            delete[] ssid;
-        }
-        if (NULL != password) {
-            delete[] password;
-        }
-    }
-};
-
-struct loc_eng_msg_release_bit : public loc_eng_msg {
-    const loc_if_req_type_e_type ifType;
-    const int ipv4Addr;
-    char* const ipv6Addr;
-    inline loc_eng_msg_release_bit(void* instance,
-                                   loc_if_req_type_e_type type,
-                                   int ipv4,
-                                   char* ipv6) :
-        loc_eng_msg(instance, LOC_ENG_MSG_RELEASE_BIT),
-        ifType(type), ipv4Addr(ipv4),
-        ipv6Addr(NULL == ipv6 ? NULL : new char[16])
-    {
-        if (NULL != ipv6Addr)
-            memcpy(ipv6Addr, ipv6, 16);
-        LOC_LOGV("ifType: %d, ipv4: %d.%d.%d.%d, ipv6: %s", ifType,
-                 (unsigned char)(ipv4>>24),
-                 (unsigned char)(ipv4>>16),
-                 (unsigned char)(ipv4>>8),
-                 (unsigned char)ipv4,
-                 NULL != ipv6Addr ? ipv6Addr : "");
-    }
-
-    inline ~loc_eng_msg_release_bit()
-    {
-        if (NULL != ipv6Addr) {
-            delete[] ipv6Addr;
-        }
-    }
-};
-
-struct loc_eng_msg_release_wifi : public loc_eng_msg {
-    const loc_if_req_type_e_type ifType;
-    const loc_if_req_sender_id_e_type senderId;
-    char* const ssid;
-    char* const password;
-    inline loc_eng_msg_release_wifi(void* instance,
-                                   loc_if_req_type_e_type type,
-                                   loc_if_req_sender_id_e_type sender_id,
-                                   char* s,
-                                   char* p) :
-        loc_eng_msg(instance, LOC_ENG_MSG_RELEASE_WIFI),
-        ifType(type), senderId(sender_id),
-        ssid(NULL == s ? NULL : new char[SSID_BUF_SIZE]),
-        password(NULL == p ? NULL : new char[SSID_BUF_SIZE])
-    {
-        if (NULL != s)
-            strlcpy(ssid, s, SSID_BUF_SIZE);
-        if (NULL != p)
-            strlcpy(password, p, SSID_BUF_SIZE);
-        LOC_LOGV("ifType: %d, senderId: %d, ssid: %s, password: %s",
-                 ifType,
-                 senderId,
-                 NULL != ssid ? ssid : "",
-                 NULL != password ? password : "");
-    }
-
-    inline ~loc_eng_msg_release_wifi()
-    {
-        if (NULL != ssid) {
-            delete[] ssid;
-        }
-        if (NULL != password) {
-            delete[] password;
-        }
-    }
-};
-
-
-struct loc_eng_msg_request_atl : public loc_eng_msg {
-    const int handle;
-    const AGpsType type;
-    inline loc_eng_msg_request_atl(void* instance, int hndl,
-                                   AGpsType agps_type) :
-        loc_eng_msg(instance, LOC_ENG_MSG_REQUEST_ATL),
-        handle(hndl), type(agps_type)
-    {
-        LOC_LOGV("handle: %d\n  agps type: %s",
-                 handle,
-                 loc_get_agps_type_name(type));
-    }
-};
-
-struct loc_eng_msg_release_atl : public loc_eng_msg {
-    const int handle;
-    inline loc_eng_msg_release_atl(void* instance, int hndl) :
-        loc_eng_msg(instance, LOC_ENG_MSG_RELEASE_ATL), handle(hndl)
-    {
-        LOC_LOGV("handle: %d", handle);
-    }
-};
-
-struct loc_eng_msg_request_ni : public loc_eng_msg {
-    const GpsNiNotification notify;
-    const void *passThroughData;
-    inline loc_eng_msg_request_ni(void* instance,
-                                  GpsNiNotification &notif, const void* data) :
-        loc_eng_msg(instance, LOC_ENG_MSG_REQUEST_NI),
-        notify(notif), passThroughData(data)
-    {
-        LOC_LOGV("id: %d\n  type: %s\n  flags: %d\n  time out: %d\n  default response: %s\n  requestor id encoding: %s\n  text encoding: %s\n  passThroughData: %p",
-                 notify.notification_id,
-                 loc_get_ni_type_name(notify.ni_type),
-                 notify.notify_flags,
-                 notify.timeout,
-                 loc_get_ni_response_name(notify.default_response),
-                 loc_get_ni_encoding_name(notify.requestor_id_encoding),
-                 loc_get_ni_encoding_name(notify.text_encoding),
-                 passThroughData);
-    }
-};
-
-struct loc_eng_msg_inform_ni_response : public loc_eng_msg {
-    const GpsUserResponseType response;
-    const void *passThroughData;
-    inline loc_eng_msg_inform_ni_response(void* instance,
-                                          GpsUserResponseType resp,
-                                          const void* data) :
-        loc_eng_msg(instance, LOC_ENG_MSG_INFORM_NI_RESPONSE),
-        response(resp), passThroughData(data)
-    {
-        LOC_LOGV("response: %s\n  passThroughData: %p",
-                 loc_get_ni_response_name(response),
-                 passThroughData);
-    }
-    inline ~loc_eng_msg_inform_ni_response()
-    {
-        // this is a bit weird since passThroughData is not
-        // allocated by this class.  But there is no better way.
-        // passThroughData actually won't be NULL here.
-        // But better safer than sorry.
-        if (NULL != passThroughData) {
-            free((void*)passThroughData);
-        }
-    }
-};
-
-struct loc_eng_msg_set_apn : public loc_eng_msg {
-    char* const apn;
-    inline loc_eng_msg_set_apn(void* instance, const char* name, int len) :
-        loc_eng_msg(instance, LOC_ENG_MSG_SET_APN),
-        apn(new char[len+1])
-    {
-        memcpy((void*)apn, (void*)name, len);
-        apn[len] = 0;
-        LOC_LOGV("apn: %s", apn);
-    }
-    inline ~loc_eng_msg_set_apn()
-    {
-        delete[] apn;
-    }
-};
-
-
-
-struct loc_eng_msg_set_server_ipv4 : public loc_eng_msg {
-    const unsigned int nl_addr;
-    const int port;
-    const LocServerType serverType;
-    inline loc_eng_msg_set_server_ipv4(void* instance,
-                                       unsigned int ip,
-                                       int p,
-                                       LocServerType type) :
-        loc_eng_msg(instance, LOC_ENG_MSG_SET_SERVER_IPV4),
-        nl_addr(ip), port(p), serverType(type)
-    {
-        LOC_LOGV("addr: %x\n  , port: %d\n type: %s", nl_addr, port, loc_get_server_type_name(serverType));
-    }
-};
-
-
-struct loc_eng_msg_set_server_url : public loc_eng_msg {
-    const int len;
-    char* const url;
-    inline loc_eng_msg_set_server_url(void* instance,
-                                      const char* urlString,
-                                      int url_len) :
-        loc_eng_msg(instance, LOC_ENG_MSG_SET_SERVER_URL),
-        len(url_len), url(new char[len+1])
-    {
-        memcpy((void*)url, (void*)urlString, url_len);
-        url[len] = 0;
-        LOC_LOGV("url: %s", url);
-    }
-    inline ~loc_eng_msg_set_server_url()
-    {
-        delete[] url;
-    }
-};
-
-struct loc_eng_msg_inject_xtra_data : public loc_eng_msg {
-    char* const data;
-    const int length;
-    inline loc_eng_msg_inject_xtra_data(void* instance, char* d, int l) :
-        loc_eng_msg(instance, LOC_ENG_MSG_INJECT_XTRA_DATA),
-        data(new char[l]), length(l)
-    {
-        memcpy((void*)data, (void*)d, l);
-        LOC_LOGV("length: %d\n  data: %p", length, data);
-    }
-    inline ~loc_eng_msg_inject_xtra_data()
-    {
-        delete[] data;
-    }
-};
-
-struct loc_eng_msg_atl_open_success : public loc_eng_msg {
-    const AGpsStatusValue agpsType;
-    const int length;
-    char* const apn;
-    const AGpsBearerType bearerType;
-    inline loc_eng_msg_atl_open_success(void* instance,
-                                        AGpsStatusValue atype,
-                                        const char* name,
-                                        int len,
-                                        AGpsBearerType btype) :
-        loc_eng_msg(instance, LOC_ENG_MSG_ATL_OPEN_SUCCESS),
-        agpsType(atype), length(len),
-        apn(new char[len+1]), bearerType(btype)
-    {
-        memcpy((void*)apn, (void*)name, len);
-        apn[len] = 0;
-        LOC_LOGV("agps type: %s\n  apn: %s\n  bearer type: %s",
-                 loc_get_agps_type_name(agpsType),
-                 apn,
-                 loc_get_agps_bear_name(bearerType));
-    }
-    inline ~loc_eng_msg_atl_open_success()
-    {
-        delete[] apn;
-    }
-};
-
-struct loc_eng_msg_atl_open_failed : public loc_eng_msg {
-    const AGpsStatusValue agpsType;
-    inline loc_eng_msg_atl_open_failed(void* instance,
-                                       AGpsStatusValue atype) :
-        loc_eng_msg(instance, LOC_ENG_MSG_ATL_OPEN_FAILED),
-        agpsType(atype)
-    {
-        LOC_LOGV("agps type %s",
-                 loc_get_agps_type_name(agpsType));
-    }
-};
-
-struct loc_eng_msg_atl_closed : public loc_eng_msg {
-    const AGpsStatusValue agpsType;
-    inline loc_eng_msg_atl_closed(void* instance,
-                                  AGpsStatusValue atype) :
-        loc_eng_msg(instance, LOC_ENG_MSG_ATL_CLOSED),
-        agpsType(atype)
-    {
-        LOC_LOGV("agps type %s",
-                 loc_get_agps_type_name(agpsType));
-    }
-};
-
-struct loc_eng_msg_set_data_enable : public loc_eng_msg {
-    const int enable;
-    char* const apn;
-    const int length;
-    inline loc_eng_msg_set_data_enable(void* instance,
-                                       const char* name,
-                                       int len,
-                                       int yes) :
-        loc_eng_msg(instance, LOC_ENG_MSG_ENABLE_DATA),
-        enable(yes), apn(new char[len+1]), length(len)
-    {
-        memcpy((void*)apn, (void*)name, len);
-        apn[len] = 0;
-        LOC_LOGV("apn: %s\n  enable: %d", apn, enable);
-    }
-    inline ~loc_eng_msg_set_data_enable()
-    {
-        delete[] apn;
-    }
-};
-
-struct loc_eng_msg_request_network_position : public loc_eng_msg {
-    const UlpNetworkRequestPos networkPosRequest;
-    inline loc_eng_msg_request_network_position (void* instance, UlpNetworkRequestPos networkPosReq) :
-        loc_eng_msg(instance, LOC_ENG_MSG_REQUEST_NETWORK_POSIITON),
-        networkPosRequest(networkPosReq)
-    {
-        LOC_LOGV("network position request: desired pos source %d\n  request type: %d\n interval ms: %d ",
-             networkPosReq.desired_position_source,
-             networkPosReq.request_type,
-             networkPosReq.interval_ms);
-    }
-};
-
-struct loc_eng_msg_request_phone_context : public loc_eng_msg {
-    const UlpPhoneContextRequest contextRequest;
-    inline loc_eng_msg_request_phone_context (void* instance, UlpPhoneContextRequest contextReq) :
-        loc_eng_msg(instance, LOC_ENG_MSG_REQUEST_PHONE_CONTEXT),
-        contextRequest(contextReq)
-    {
-        LOC_LOGV("phone context request: request type 0x%x context type: 0x%x ",
-             contextRequest.request_type,
-             contextRequest.context_type);
-    }
-};
-
-struct ulp_msg_update_criteria : public loc_eng_msg {
-    const UlpLocationCriteria locationCriteria;
-    inline ulp_msg_update_criteria (void* instance, UlpLocationCriteria criteria) :
-        loc_eng_msg(instance, ULP_MSG_UPDATE_CRITERIA),
-        locationCriteria(criteria)
-    {
-        LOC_LOGV("location criteria: aciton %d\n  valid mask: %d\n provider source: %d\n accuracy %d\n recurrence type %d\n min interval %d\n power consumption %d\n intermediate pos %d ",
-             locationCriteria.action,
-             locationCriteria.valid_mask,
-             locationCriteria.provider_source,
-             locationCriteria.preferred_horizontal_accuracy,
-             locationCriteria.recurrence_type,
-             locationCriteria.min_interval,
-             locationCriteria.preferred_power_consumption,
-             locationCriteria.intermediate_pos_report_enabled);
-    }
-};
-
-struct ulp_msg_inject_raw_command : public loc_eng_msg {
-    const char* rawCommand;
-    const int rawCommandLength;
-    inline ulp_msg_inject_raw_command (void* instance, char* command, int length) :
-        loc_eng_msg(instance, ULP_MSG_INJECT_RAW_COMMAND),
-        rawCommand(new char[length]),
-        rawCommandLength(length)
-    {
-      memcpy((void*)rawCommand, (void*)command, length);
-      LOC_LOGV("inject raw command: command %s\n  command length: %d\n ",
-             rawCommand,
-             rawCommandLength);
-    }
-
-    inline ~ulp_msg_inject_raw_command()
-    {
-        delete[] rawCommand;
-    }
-};
-
-struct ulp_msg_inject_phone_context_settings : public loc_eng_msg {
-    const UlpPhoneContextSettings phoneSetting;
-    inline ulp_msg_inject_phone_context_settings(void* instance, UlpPhoneContextSettings setting) :
-        loc_eng_msg(instance, ULP_MSG_INJECT_PHONE_CONTEXT_SETTINGS),
-        phoneSetting(setting)
-    {
-        LOC_LOGV("context type: %d\n  gps enabled: %d\n network position available %d\n wifi setting enabled %d\n battery charging %d"
-                 "is_agps_setting_enabled %d, is_enh_location_services_enabled %d\n",
-             phoneSetting.context_type,
-             phoneSetting.is_gps_enabled,
-             phoneSetting.is_network_position_available,
-             phoneSetting.is_wifi_setting_enabled,
-             phoneSetting.is_battery_charging,
-             phoneSetting.is_agps_enabled,
-             phoneSetting.is_enh_location_services_enabled);
-    }
-};
-
-struct ulp_msg_inject_network_position : public loc_eng_msg {
-    const UlpNetworkPositionReport networkPosition;
-    inline ulp_msg_inject_network_position(void* instance, UlpNetworkPositionReport networkPos) :
-        loc_eng_msg(instance, ULP_MSG_INJECT_NETWORK_POSITION),
-        networkPosition(networkPos)
-    {
-        LOC_LOGV("flags: %d\n  source: %d\n  latitude: %f\n  longitude: %f\n  accuracy %d",
-             networkPosition.valid_flag,
-             networkPosition.position.pos_source,
-             networkPosition.position.latitude,
-             networkPosition.position.longitude,
-             networkPosition.position.HEPE);
-    }
-};
-
-struct ulp_msg_report_quipc_position : public loc_eng_msg {
-    const GpsLocation location;
-    const int  quipc_error_code;
-    inline ulp_msg_report_quipc_position(void* instance, GpsLocation &loc,
-                                         int  quipc_err) :
-        loc_eng_msg(instance, ULP_MSG_REPORT_QUIPC_POSITION),
-        location(loc), quipc_error_code(quipc_err)
-    {
-        LOC_LOGV("flags: %d\n  source: %d\n  latitude: %f\n  longitude: %f\n  altitude: %f\n  speed: %f\n  bearing: %f\n  accuracy: %f\n  timestamp: %lld\n  rawDataSize: %d\n  rawData: %p\n  Quipc error: %d",
-                 location.flags, location.position_source, location.latitude, location.longitude,
-                 location.altitude, location.speed, location.bearing, location.accuracy,
-                 location.timestamp, location.rawDataSize, location.rawData,
-                 quipc_error_code);
-    }
-};
-
-struct loc_eng_msg_privacy : public loc_eng_msg {
-    const int8_t privacy_setting;
-    inline loc_eng_msg_privacy(void* instance, int8_t privacy_setting) :
-        loc_eng_msg(instance, LOC_ENG_MSG_PRIVACY),
-        privacy_setting(privacy_setting)
-        {
-            LOC_LOGV("privacy_setting: %d", privacy_setting);
-        }
-};
-
-void loc_eng_msg_sender(void* loc_eng_data_p, void* msg);
-int loc_eng_msgget(int * p_req_msgq);
-int loc_eng_msgremove(int req_msgq);
-int loc_eng_msgsnd(int msgqid, void * msgp);
-int loc_eng_msgrcv(int msgqid, void ** msgp);
-int loc_eng_msgsnd_raw(int msgqid, void * msgp, unsigned int msgsz);
-int loc_eng_msgrcv_raw(int msgqid, void *msgp, unsigned int msgsz);
-int loc_eng_msgflush(int msgqid);
-int loc_eng_msgunblock(int msgqid);
-
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
-
-#endif /* LOC_ENG_MSG_H */