diff --git a/gps/core/ContextBase.cpp b/gps/core/ContextBase.cpp index 9f6c4aa..971354d 100644 --- a/gps/core/ContextBase.cpp +++ b/gps/core/ContextBase.cpp @@ -40,6 +40,27 @@ namespace loc_core { +loc_gps_cfg_s_type ContextBase::mGps_conf {0}; +loc_sap_cfg_s_type ContextBase::mSap_conf {0}; + +uint32_t ContextBase::getCarrierCapabilities() { + #define carrierMSA (uint32_t)0x2 + #define carrierMSB (uint32_t)0x1 + #define gpsConfMSA (uint32_t)0x4 + #define gpsConfMSB (uint32_t)0x2 + uint32_t capabilities = mGps_conf.CAPABILITIES; + if ((mGps_conf.SUPL_MODE & carrierMSA) != carrierMSA) { + capabilities &= ~gpsConfMSA; + } + if ((mGps_conf.SUPL_MODE & carrierMSB) != carrierMSB) { + capabilities &= ~gpsConfMSB; + } + + LOC_LOGV("getCarrierCapabilities: CAPABILITIES %x, SUPL_MODE %x, carrier capabilities %x", + mGps_conf.CAPABILITIES, mGps_conf.SUPL_MODE, capabilities); + return capabilities; +} + LBSProxyBase* ContextBase::getLBSProxy(const char* libName) { LBSProxyBase* proxy = NULL; diff --git a/gps/core/ContextBase.h b/gps/core/ContextBase.h index fe0b860..4f7ac39 100644 --- a/gps/core/ContextBase.h +++ b/gps/core/ContextBase.h @@ -35,6 +35,67 @@ #include #include +#define MAX_XTRA_SERVER_URL_LENGTH 256 + +/* GPS.conf support */ +/* NOTE: the implementaiton of the parser casts number + fields to 32 bit. To ensure all 'n' fields working, + they must all be 32 bit fields. */ +typedef struct loc_gps_cfg_s +{ + uint32_t INTERMEDIATE_POS; + uint32_t ACCURACY_THRES; + uint32_t SUPL_VER; + uint32_t SUPL_MODE; + uint32_t SUPL_ES; + uint32_t CAPABILITIES; + uint32_t LPP_PROFILE; + uint32_t XTRA_VERSION_CHECK; + char XTRA_SERVER_1[MAX_XTRA_SERVER_URL_LENGTH]; + char XTRA_SERVER_2[MAX_XTRA_SERVER_URL_LENGTH]; + char XTRA_SERVER_3[MAX_XTRA_SERVER_URL_LENGTH]; + uint32_t USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL; + uint32_t NMEA_PROVIDER; + uint32_t GPS_LOCK; + uint32_t A_GLONASS_POS_PROTOCOL_SELECT; + uint32_t AGPS_CERT_WRITABLE_MASK; + uint32_t LPPE_CP_TECHNOLOGY; + uint32_t LPPE_UP_TECHNOLOGY; +} loc_gps_cfg_s_type; + +/* NOTE: the implementaiton of the parser casts number + fields to 32 bit. To ensure all 'n' fields working, + they must all be 32 bit fields. */ +/* Meanwhile, *_valid fields are 8 bit fields, and 'f' + fields are double. Rigid as they are, it is the + the status quo, until the parsing mechanism is + change, that is. */ +typedef struct +{ + uint8_t GYRO_BIAS_RANDOM_WALK_VALID; + double GYRO_BIAS_RANDOM_WALK; + uint32_t SENSOR_ACCEL_BATCHES_PER_SEC; + uint32_t SENSOR_ACCEL_SAMPLES_PER_BATCH; + uint32_t SENSOR_GYRO_BATCHES_PER_SEC; + uint32_t SENSOR_GYRO_SAMPLES_PER_BATCH; + uint32_t SENSOR_ACCEL_BATCHES_PER_SEC_HIGH; + uint32_t SENSOR_ACCEL_SAMPLES_PER_BATCH_HIGH; + uint32_t SENSOR_GYRO_BATCHES_PER_SEC_HIGH; + uint32_t SENSOR_GYRO_SAMPLES_PER_BATCH_HIGH; + uint32_t SENSOR_CONTROL_MODE; + uint32_t SENSOR_USAGE; + uint32_t SENSOR_ALGORITHM_CONFIG_MASK; + uint8_t ACCEL_RANDOM_WALK_SPECTRAL_DENSITY_VALID; + double ACCEL_RANDOM_WALK_SPECTRAL_DENSITY; + uint8_t ANGLE_RANDOM_WALK_SPECTRAL_DENSITY_VALID; + double ANGLE_RANDOM_WALK_SPECTRAL_DENSITY; + uint8_t RATE_RANDOM_WALK_SPECTRAL_DENSITY_VALID; + double RATE_RANDOM_WALK_SPECTRAL_DENSITY; + uint8_t VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY_VALID; + double VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY; + uint32_t SENSOR_PROVIDER; +} loc_sap_cfg_s_type; + namespace loc_core { class LocAdapterBase; @@ -58,6 +119,7 @@ public: inline LocApiProxyBase* getLocApiProxy() { return mLocApiProxy; } inline bool hasAgpsExtendedCapabilities() { return mLBSProxy->hasAgpsExtendedCapabilities(); } inline bool hasCPIExtendedCapabilities() { return mLBSProxy->hasCPIExtendedCapabilities(); } + inline bool hasNativeXtraClient() { return mLBSProxy->hasNativeXtraClient(); } inline void modemPowerVote(bool power) const { return mLBSProxy->modemPowerVote(power); } inline void requestUlp(LocAdapterBase* adapter, unsigned long capabilities) { @@ -67,6 +129,12 @@ public: return mLBSProxy->getIzatDevId(); } inline void sendMsg(const LocMsg *msg) { getMsgTask()->sendMsg(msg); } + + static loc_gps_cfg_s_type mGps_conf; + static loc_sap_cfg_s_type mSap_conf; + + static uint32_t getCarrierCapabilities(); + }; } // namespace loc_core diff --git a/gps/core/LBSProxyBase.h b/gps/core/LBSProxyBase.h index 0faf801..94ddd0f 100644 --- a/gps/core/LBSProxyBase.h +++ b/gps/core/LBSProxyBase.h @@ -43,6 +43,10 @@ class LBSProxyBase { getLocApi(const MsgTask* msgTask, LOC_API_ADAPTER_EVENT_MASK_T exMask, ContextBase* context) const { + + (void)msgTask; + (void)exMask; + (void)context; return NULL; } protected: @@ -50,11 +54,22 @@ protected: public: inline virtual ~LBSProxyBase() {} inline virtual void requestUlp(LocAdapterBase* adapter, - unsigned long capabilities) const {} + unsigned long capabilities) const { + + (void)adapter; + (void)capabilities; + } inline virtual bool hasAgpsExtendedCapabilities() const { return false; } inline virtual bool hasCPIExtendedCapabilities() const { return false; } - inline virtual void modemPowerVote(bool power) const {} - virtual void injectFeatureConfig(ContextBase* context) const {} + inline virtual void modemPowerVote(bool power) const { + + (void)power; + } + virtual void injectFeatureConfig(ContextBase* context) const { + + (void)context; + } + inline virtual bool hasNativeXtraClient() const { return false; } inline virtual IzatDevId_t getIzatDevId() const { return 0; } }; diff --git a/gps/core/LocAdapterBase.cpp b/gps/core/LocAdapterBase.cpp index fbd077a..d4727d8 100644 --- a/gps/core/LocAdapterBase.cpp +++ b/gps/core/LocAdapterBase.cpp @@ -80,7 +80,7 @@ void LocAdapterBase:: } void LocAdapterBase:: - reportSv(QcomSvStatus &svStatus, + reportSv(GnssSvStatus &svStatus, GpsLocationExtended &locationExtended, void* svExt) DEFAULT_IMPL() @@ -137,6 +137,6 @@ bool LocAdapterBase:: DEFAULT_IMPL(false) void LocAdapterBase:: - reportGpsMeasurementData(GpsData &gpsMeasurementData) + reportGnssMeasurementData(GnssData &gnssMeasurementData) DEFAULT_IMPL() } // namespace loc_core diff --git a/gps/core/LocAdapterBase.h b/gps/core/LocAdapterBase.h index d3adfe9..2c7a2e8 100644 --- a/gps/core/LocAdapterBase.h +++ b/gps/core/LocAdapterBase.h @@ -1,4 +1,4 @@ -/* Copyright (c) 2011-2014, The Linux Foundation. All rights reserved. +/* Copyright (c) 2011-2014,2016 The Linux Foundation. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are @@ -78,12 +78,22 @@ public: mLocApi->updateEvtMask(); } + inline bool isFeatureSupported(uint8_t featureVal) { + return mLocApi->isFeatureSupported(featureVal); + } + // This will be overridden by the individual adapters // if necessary. - inline virtual void setUlpProxy(UlpProxyBase* ulp) {} + inline virtual void setUlpProxy(UlpProxyBase* ulp) { + + (void)ulp; + } virtual void handleEngineUpEvent(); virtual void handleEngineDownEvent(); - inline virtual void setPositionModeInt(LocPosMode& posMode) {} + inline virtual void setPositionModeInt(LocPosMode& posMode) { + + (void)posMode; + } virtual void startFixInt() {} virtual void stopFixInt() {} virtual void getZppInt() {} @@ -92,7 +102,7 @@ public: void* locationExt, enum loc_sess_status status, LocPosTechMask loc_technology_mask); - virtual void reportSv(QcomSvStatus &svStatus, + virtual void reportSv(GnssSvStatus &svStatus, GpsLocationExtended &locationExtended, void* svExt); virtual void reportStatus(GpsStatusValue status); @@ -111,7 +121,7 @@ public: const void* data); inline virtual bool isInSession() { return false; } ContextBase* getContext() const { return mContext; } - virtual void reportGpsMeasurementData(GpsData &gpsMeasurementData); + virtual void reportGnssMeasurementData(GnssData &gnssMeasurementData); }; } // namespace loc_core diff --git a/gps/core/LocAdapterProxyBase.h b/gps/core/LocAdapterProxyBase.h index 1ddcca4..82cba6b 100644 --- a/gps/core/LocAdapterProxyBase.h +++ b/gps/core/LocAdapterProxyBase.h @@ -46,21 +46,26 @@ protected: inline virtual ~LocAdapterProxyBase() { delete mLocAdapterBase; } - ContextBase* getContext() const { - return mLocAdapterBase->getContext(); - } inline void updateEvtMask(LOC_API_ADAPTER_EVENT_MASK_T event, loc_registration_mask_status isEnabled) { mLocAdapterBase->updateEvtMask(event,isEnabled); } public: + inline ContextBase* getContext() const { + return mLocAdapterBase->getContext(); + } inline virtual void handleEngineUpEvent() {}; inline virtual void handleEngineDownEvent() {}; inline virtual bool reportPosition(UlpLocation &location, GpsLocationExtended &locationExtended, enum loc_sess_status status, LocPosTechMask loc_technology_mask) { + + (void)location; + (void)locationExtended; + (void)status; + (void)loc_technology_mask; return false; } }; diff --git a/gps/core/LocApiBase.cpp b/gps/core/LocApiBase.cpp index 8247d0a..85bc7c1 100644 --- a/gps/core/LocApiBase.cpp +++ b/gps/core/LocApiBase.cpp @@ -1,4 +1,4 @@ -/* Copyright (c) 2011-2014, The Linux Foundation. All rights reserved. +/* Copyright (c) 2011-2014,2016 The Linux Foundation. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are @@ -132,6 +132,7 @@ LocApiBase::LocApiBase(const MsgTask* msgTask, mMask(0), mSupportedMsg(0), mContext(context) { memset(mLocAdapters, 0, sizeof(mLocAdapters)); + memset(mFeaturesSupported, 0, sizeof(mFeaturesSupported)); } LOC_API_ADAPTER_EVENT_MASK_T LocApiBase::getEvtMask() @@ -253,23 +254,21 @@ void LocApiBase::reportPosition(UlpLocation &location, ); } -void LocApiBase::reportSv(QcomSvStatus &svStatus, +void LocApiBase::reportSv(GnssSvStatus &svStatus, GpsLocationExtended &locationExtended, void* svExt) { // print the SV info before delivering - LOC_LOGV("num sv: %d\n ephemeris mask: %dxn almanac mask: %x\n gps/glo/bds in use" - " mask: %x/%x/%x\n sv: prn snr elevation azimuth", - svStatus.num_svs, svStatus.ephemeris_mask, - svStatus.almanac_mask, svStatus.gps_used_in_fix_mask, - svStatus.glo_used_in_fix_mask, svStatus.bds_used_in_fix_mask); - for (int i = 0; i < svStatus.num_svs && i < GPS_MAX_SVS; i++) { - LOC_LOGV(" %d: %d %f %f %f", + LOC_LOGV("num sv: %d", svStatus.num_svs); + for (int i = 0; i < svStatus.num_svs && i < GNSS_MAX_SVS; i++) { + LOC_LOGV(" %03d: %02d %d %f %f %f 0x%02X", i, - svStatus.sv_list[i].prn, - svStatus.sv_list[i].snr, - svStatus.sv_list[i].elevation, - svStatus.sv_list[i].azimuth); + svStatus.gnss_sv_list[i].svid, + svStatus.gnss_sv_list[i].constellation, + svStatus.gnss_sv_list[i].c_n0_dbhz, + svStatus.gnss_sv_list[i].elevation, + svStatus.gnss_sv_list[i].azimuth, + svStatus.gnss_sv_list[i].flags); } // loop through adapters, and deliver to all adapters. TO_ALL_LOCADAPTERS( @@ -358,16 +357,21 @@ void LocApiBase::saveSupportedMsgList(uint64_t supportedMsgList) mSupportedMsg = supportedMsgList; } +void LocApiBase::saveSupportedFeatureList(uint8_t *featureList) +{ + memcpy((void *)mFeaturesSupported, (void *)featureList, sizeof(mFeaturesSupported)); +} + void* LocApiBase :: getSibling() DEFAULT_IMPL(NULL) LocApiProxyBase* LocApiBase :: getLocApiProxy() DEFAULT_IMPL(NULL) -void LocApiBase::reportGpsMeasurementData(GpsData &gpsMeasurementData) +void LocApiBase::reportGnssMeasurementData(GnssData &gnssMeasurementData) { // loop through adapters, and deliver to all adapters. - TO_ALL_LOCADAPTERS(mLocAdapters[i]->reportGpsMeasurementData(gpsMeasurementData)); + TO_ALL_LOCADAPTERS(mLocAdapters[i]->reportGnssMeasurementData(gnssMeasurementData)); } enum loc_api_adapter_err LocApiBase:: @@ -445,6 +449,10 @@ enum loc_api_adapter_err LocApiBase:: setSUPLVersion(uint32_t version) DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) +enum loc_api_adapter_err LocApiBase:: + setNMEATypes (uint32_t typesMask) +DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) + enum loc_api_adapter_err LocApiBase:: setLPPConfig(uint32_t profile) DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) @@ -481,12 +489,12 @@ enum loc_api_adapter_err LocApiBase:: DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) enum loc_api_adapter_err LocApiBase:: - setExtPowerConfig(int isBatteryCharging) + setAGLONASSProtocol(unsigned long aGlonassProtocol) DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) enum loc_api_adapter_err LocApiBase:: - setAGLONASSProtocol(unsigned long aGlonassProtocol) -DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) + setLPPeProtocol(unsigned long lppeCP, unsigned long lppeUP) + DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) enum loc_api_adapter_err LocApiBase:: getWwanZppFix(GpsLocation& zppLoc) @@ -550,4 +558,14 @@ bool LocApiBase:: gnssConstellationConfig() DEFAULT_IMPL(false) +bool LocApiBase:: + isFeatureSupported(uint8_t featureVal) +{ + uint8_t arrayIndex = featureVal >> 3; + uint8_t bitPos = featureVal & 7; + + if (arrayIndex >= MAX_FEATURE_LENGTH) return false; + return ((mFeaturesSupported[arrayIndex] >> bitPos ) & 0x1); +} + } // namespace loc_core diff --git a/gps/core/LocApiBase.h b/gps/core/LocApiBase.h index 9ea5560..0edc469 100644 --- a/gps/core/LocApiBase.h +++ b/gps/core/LocApiBase.h @@ -1,4 +1,4 @@ -/* Copyright (c) 2011-2014, The Linux Foundation. All rights reserved. +/* Copyright (c) 2011-2014, 2016 The Linux Foundation. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are @@ -44,6 +44,7 @@ int decodeAddress(char *addr_string, int string_size, const char *data, int data_size); #define MAX_ADAPTERS 10 +#define MAX_FEATURE_LENGTH 100 #define TO_ALL_ADAPTERS(adapters, call) \ for (int i = 0; i < MAX_ADAPTERS && NULL != (adapters)[i]; i++) { \ @@ -81,6 +82,7 @@ class LocApiBase { ContextBase *mContext; LocAdapterBase* mLocAdapters[MAX_ADAPTERS]; uint64_t mSupportedMsg; + uint8_t mFeaturesSupported[MAX_FEATURE_LENGTH]; protected: virtual enum loc_api_adapter_err @@ -113,7 +115,7 @@ public: enum loc_sess_status status, LocPosTechMask loc_technology_mask = LOC_POS_TECH_MASK_DEFAULT); - void reportSv(QcomSvStatus &svStatus, + void reportSv(GnssSvStatus &svStatus, GpsLocationExtended &locationExtended, void* svExt); void reportStatus(GpsStatusValue status); @@ -130,7 +132,8 @@ public: void reportDataCallClosed(); void requestNiNotify(GpsNiNotification ¬ify, const void* data); void saveSupportedMsgList(uint64_t supportedMsgList); - void reportGpsMeasurementData(GpsData &gpsMeasurementData); + void reportGnssMeasurementData(GnssData &gnssMeasurementData); + void saveSupportedFeatureList(uint8_t *featureList); // downward calls // All below functions are to be defined by adapter specific modules: @@ -171,6 +174,8 @@ public: informNiResponse(GpsUserResponseType userResponse, const void* passThroughData); virtual enum loc_api_adapter_err setSUPLVersion(uint32_t version); + virtual enum loc_api_adapter_err + setNMEATypes (uint32_t typesMask); virtual enum loc_api_adapter_err setLPPConfig(uint32_t profile); virtual enum loc_api_adapter_err @@ -197,10 +202,10 @@ public: int gyroSamplesPerBatchHigh, int gyroBatchesPerSecHigh, int algorithmConfig); - virtual enum loc_api_adapter_err - setExtPowerConfig(int isBatteryCharging); virtual enum loc_api_adapter_err setAGLONASSProtocol(unsigned long aGlonassProtocol); + virtual enum loc_api_adapter_err + setLPPeProtocol(unsigned long lppeCP, unsigned long lppeUP); virtual enum loc_api_adapter_err getWwanZppFix(GpsLocation & zppLoc); virtual enum loc_api_adapter_err @@ -214,9 +219,15 @@ public: virtual void installAGpsCert(const DerEncodedCertificate* pData, size_t length, uint32_t slotBitMask); - inline virtual void setInSession(bool inSession) {} + inline virtual void setInSession(bool inSession) { + + (void)inSession; + } inline bool isMessageSupported (LocCheckingMessagesID msgID) const { - if (msgID > (sizeof(mSupportedMsg) << 3)) { + + // confirm if msgID is not larger than the number of bits in + // mSupportedMsg + if ((uint64_t)msgID > (sizeof(mSupportedMsg) << 3)) { return false; } else { uint32_t messageChecker = 1 << msgID; @@ -250,6 +261,11 @@ public: Check if the modem support the service */ virtual bool gnssConstellationConfig(); + + /* + Check if a feature is supported + */ + bool isFeatureSupported(uint8_t featureVal); }; typedef LocApiBase* (getLocApi_t)(const MsgTask* msgTask, diff --git a/gps/core/UlpProxyBase.h b/gps/core/UlpProxyBase.h index 3db0837..3ff3e59 100644 --- a/gps/core/UlpProxyBase.h +++ b/gps/core/UlpProxyBase.h @@ -1,4 +1,4 @@ -/* Copyright (c) 2013-2015, The Linux Foundation. All rights reserved. +/* Copyright (c) 2013-2016, The Linux Foundation. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are @@ -59,24 +59,45 @@ public: void* locationExt, enum loc_sess_status status, LocPosTechMask loc_technology_mask) { + (void)location; + (void)locationExtended; + (void)locationExt; + (void)status; + (void)loc_technology_mask; return false; } - inline virtual bool reportSv(QcomSvStatus &svStatus, + inline virtual bool reportSv(GnssSvStatus &svStatus, GpsLocationExtended &locationExtended, void* svExt) { + (void)svStatus; + (void)locationExtended; + (void)svExt; return false; } inline virtual bool reportStatus(GpsStatusValue status) { + + (void)status; return false; } - inline virtual void setAdapter(LocAdapterBase* adapter) {} - inline virtual void setCapabilities(unsigned long capabilities) {} + inline virtual void setAdapter(LocAdapterBase* adapter) { + + (void)adapter; + } + inline virtual void setCapabilities(unsigned long capabilities) { + + (void)capabilities; + } inline virtual bool reportBatchingSession(FlpExtBatchOptions &options, bool active) { + + (void)options; + (void)active; return false; } inline virtual bool reportPositions(const struct FlpExtLocation_s* locations, int32_t number_of_locations) { + (void)locations; + (void)number_of_locations; return false; } }; diff --git a/gps/core/gps_extended_c.h b/gps/core/gps_extended_c.h index b3c1092..6ff692a 100644 --- a/gps/core/gps_extended_c.h +++ b/gps/core/gps_extended_c.h @@ -1,4 +1,4 @@ -/* Copyright (c) 2013-2015, The Linux Foundation. All rights reserved. +/* Copyright (c) 2013-2015, 2016 The Linux Foundation. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are @@ -82,6 +82,11 @@ enum loc_registration_mask_status { LOC_REGISTRATION_MASK_DISABLED }; +typedef enum { + LOC_SUPPORTED_FEATURE_ODCPI_2_V02 = 0, /**< Support ODCPI version 2 feature */ + LOC_SUPPORTED_FEATURE_WIFI_AP_DATA_INJECT_2_V02 /**< Support Wifi AP data inject version 2 feature */ +} loc_supported_feature_enum; + typedef struct { /** set to sizeof(UlpLocation) */ size_t size; @@ -165,14 +170,14 @@ typedef struct { } AGpsExtCallbacks; +typedef void (*loc_ni_notify_callback)(GpsNiNotification *notification, bool esEnalbed); /** GPS NI callback structure. */ typedef struct { /** * Sends the notification request from HAL to GPSLocationProvider. */ - gps_ni_notify_callback notify_cb; - gps_create_thread create_thread_cb; + loc_ni_notify_callback notify_cb; } GpsNiExtCallbacks; typedef enum loc_server_type { @@ -217,6 +222,12 @@ typedef uint16_t GpsLocationExtendedFlags; #define GPS_LOCATION_EXTENDED_HAS_HOR_RELIABILITY 0x0080 /** GpsLocationExtended has valid vertical reliability */ #define GPS_LOCATION_EXTENDED_HAS_VERT_RELIABILITY 0x0100 +/** GpsLocationExtended has valid Horizontal Elliptical Uncertainty (Semi-Major Axis) */ +#define GPS_LOCATION_EXTENDED_HAS_HOR_ELIP_UNC_MAJOR 0x0200 +/** GpsLocationExtended has valid Horizontal Elliptical Uncertainty (Semi-Minor Axis) */ +#define GPS_LOCATION_EXTENDED_HAS_HOR_ELIP_UNC_MINOR 0x0400 +/** GpsLocationExtended has valid Elliptical Horizontal Uncertainty Azimuth */ +#define GPS_LOCATION_EXTENDED_HAS_HOR_ELIP_UNC_AZIMUTH 0x0800 typedef enum { LOC_RELIABILITY_NOT_SET = 0, @@ -252,49 +263,14 @@ typedef struct { LocReliability horizontal_reliability; /** vertical reliability. */ LocReliability vertical_reliability; + /* Horizontal Elliptical Uncertainty (Semi-Major Axis) */ + float horUncEllipseSemiMajor; + /* Horizontal Elliptical Uncertainty (Semi-Minor Axis) */ + float horUncEllipseSemiMinor; + /* Elliptical Horizontal Uncertainty Azimuth */ + float horUncEllipseOrientAzimuth; } GpsLocationExtended; -/** Represents SV status. */ -typedef struct { - /** set to sizeof(QcomSvStatus) */ - size_t size; - - /** Number of SVs currently visible. */ - int num_svs; - - /** Contains an array of SV information. */ - GpsSvInfo sv_list[GPS_MAX_SVS]; - - /** Represents a bit mask indicating which SVs - * have ephemeris data. - */ - uint32_t ephemeris_mask; - - /** Represents a bit mask indicating which SVs - * have almanac data. - */ - uint32_t almanac_mask; - - /** - * Represents a bit mask indicating which GPS SVs - * were used for computing the most recent position fix. - */ - uint32_t gps_used_in_fix_mask; - - /** - * Represents a bit mask indicating which GLONASS SVs - * were used for computing the most recent position fix. - */ - uint32_t glo_used_in_fix_mask; - - /** - * Represents a bit mask indicating which BDS SVs - * were used for computing the most recent position fix. - */ - uint64_t bds_used_in_fix_mask; - -} QcomSvStatus; - enum loc_sess_status { LOC_SESS_SUCCESS, LOC_SESS_INTERMEDIATE, @@ -312,6 +288,34 @@ typedef uint32_t LocPosTechMask; #define LOC_POS_TECH_MASK_AFLT ((LocPosTechMask)0x00000040) #define LOC_POS_TECH_MASK_HYBRID ((LocPosTechMask)0x00000080) +// Nmea sentence types mask +typedef uint32_t NmeaSentenceTypesMask; +#define LOC_NMEA_MASK_GGA_V02 ((NmeaSentenceTypesMask)0x00000001) /**< Enable GGA type */ +#define LOC_NMEA_MASK_RMC_V02 ((NmeaSentenceTypesMask)0x00000002) /**< Enable RMC type */ +#define LOC_NMEA_MASK_GSV_V02 ((NmeaSentenceTypesMask)0x00000004) /**< Enable GSV type */ +#define LOC_NMEA_MASK_GSA_V02 ((NmeaSentenceTypesMask)0x00000008) /**< Enable GSA type */ +#define LOC_NMEA_MASK_VTG_V02 ((NmeaSentenceTypesMask)0x00000010) /**< Enable VTG type */ +#define LOC_NMEA_MASK_PQXFI_V02 ((NmeaSentenceTypesMask)0x00000020) /**< Enable PQXFI type */ +#define LOC_NMEA_MASK_PSTIS_V02 ((NmeaSentenceTypesMask)0x00000040) /**< Enable PSTIS type */ +#define LOC_NMEA_MASK_GLGSV_V02 ((NmeaSentenceTypesMask)0x00000080) /**< Enable GLGSV type */ +#define LOC_NMEA_MASK_GNGSA_V02 ((NmeaSentenceTypesMask)0x00000100) /**< Enable GNGSA type */ +#define LOC_NMEA_MASK_GNGNS_V02 ((NmeaSentenceTypesMask)0x00000200) /**< Enable GNGNS type */ +#define LOC_NMEA_MASK_GARMC_V02 ((NmeaSentenceTypesMask)0x00000400) /**< Enable GARMC type */ +#define LOC_NMEA_MASK_GAGSV_V02 ((NmeaSentenceTypesMask)0x00000800) /**< Enable GAGSV type */ +#define LOC_NMEA_MASK_GAGSA_V02 ((NmeaSentenceTypesMask)0x00001000) /**< Enable GAGSA type */ +#define LOC_NMEA_MASK_GAVTG_V02 ((NmeaSentenceTypesMask)0x00002000) /**< Enable GAVTG type */ +#define LOC_NMEA_MASK_GAGGA_V02 ((NmeaSentenceTypesMask)0x00004000) /**< Enable GAGGA type */ +#define LOC_NMEA_MASK_PQGSA_V02 ((NmeaSentenceTypesMask)0x00008000) /**< Enable PQGSA type */ +#define LOC_NMEA_MASK_PQGSV_V02 ((NmeaSentenceTypesMask)0x00010000) /**< Enable PQGSV type */ +#define LOC_NMEA_ALL_SUPPORTED_MASK (LOC_NMEA_MASK_GGA_V02 | LOC_NMEA_MASK_RMC_V02 | \ + LOC_NMEA_MASK_GSV_V02 | LOC_NMEA_MASK_GSA_V02 | LOC_NMEA_MASK_VTG_V02 | \ + LOC_NMEA_MASK_PQXFI_V02 | LOC_NMEA_MASK_PSTIS_V02 | LOC_NMEA_MASK_GLGSV_V02 | \ + LOC_NMEA_MASK_GNGSA_V02 | LOC_NMEA_MASK_GNGNS_V02 | LOC_NMEA_MASK_GARMC_V02 | \ + LOC_NMEA_MASK_GAGSV_V02 | LOC_NMEA_MASK_GAGSA_V02 | LOC_NMEA_MASK_GAVTG_V02 | \ + LOC_NMEA_MASK_GAGGA_V02 | LOC_NMEA_MASK_PQGSA_V02 | LOC_NMEA_MASK_PQGSV_V02 ) + + + typedef enum { LOC_ENG_IF_REQUEST_SENDER_ID_QUIPC = 0, LOC_ENG_IF_REQUEST_SENDER_ID_MSAPM, diff --git a/gps/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/LocApiRpc.h b/gps/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/LocApiRpc.h index 01d67f4..13557c9 100644 --- a/gps/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/LocApiRpc.h +++ b/gps/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/LocApiRpc.h @@ -67,9 +67,11 @@ protected: open(LOC_API_ADAPTER_EVENT_MASK_T mask); virtual enum loc_api_adapter_err close(); + LocApiRpc(const MsgTask* msgTask, + LOC_API_ADAPTER_EVENT_MASK_T exMask); public: - LocApiRpc(const MsgTask* msgTask, + static LocApiRpc* createLocApiRpc(const MsgTask* msgTask, LOC_API_ADAPTER_EVENT_MASK_T exMask); ~LocApiRpc(); diff --git a/gps/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/LocApiRpc.cpp b/gps/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/LocApiRpc.cpp index c744754..8d17695 100644 --- a/gps/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/LocApiRpc.cpp +++ b/gps/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/LocApiRpc.cpp @@ -132,6 +132,17 @@ const rpc_loc_event_mask_type LocApiRpc::locBits[] = RPC_LOC_EVENT_WPS_NEEDED_REQUEST }; +LocApiRpc* +LocApiRpc::createLocApiRpc(const MsgTask* msgTask, + LOC_API_ADAPTER_EVENT_MASK_T exMask, + ContextBase* context) +{ + if (NULL == msgTask) { + return NULL; + } + return new LocApiRpc(msgTask, exMask, context); +} + // constructor LocApiRpc::LocApiRpc(const MsgTask* msgTask, LOC_API_ADAPTER_EVENT_MASK_T exMask, @@ -797,7 +808,7 @@ void LocApiRpc::reportPosition(const rpc_loc_parsed_position_s_type *location_re void LocApiRpc::reportSv(const rpc_loc_gnss_info_s_type *gnss_report_ptr) { - GnssSvStatus SvStatus = {0}; + QtiGnssSvStatus SvStatus = {0}; GpsLocationExtended locationExtended = {0}; locationExtended.size = sizeof(locationExtended); int num_svs_max = 0; diff --git a/gps/loc_api/libloc_api_50001/Android.mk b/gps/loc_api/libloc_api_50001/Android.mk index a6d04f9..db8ebbc 100644 --- a/gps/loc_api/libloc_api_50001/Android.mk +++ b/gps/loc_api/libloc_api_50001/Android.mk @@ -88,6 +88,10 @@ LOCAL_CFLAGS += \ -fno-short-enums \ -D_ANDROID_ \ +ifeq ($(TARGET_BUILD_VARIANT),user) + LOCAL_CFLAGS += -DTARGET_BUILD_VARIANT_USER +endif + ifeq ($(TARGET_USES_QCOM_BSP), true) LOCAL_CFLAGS += -DTARGET_USES_QCOM_BSP endif diff --git a/gps/loc_api/libloc_api_50001/LocEngAdapter.cpp b/gps/loc_api/libloc_api_50001/LocEngAdapter.cpp index d721ee4..bb7aa79 100644 --- a/gps/loc_api/libloc_api_50001/LocEngAdapter.cpp +++ b/gps/loc_api/libloc_api_50001/LocEngAdapter.cpp @@ -377,14 +377,14 @@ void LocEngAdapter::reportPosition(UlpLocation &location, } } -void LocInternalAdapter::reportSv(QcomSvStatus &svStatus, +void LocInternalAdapter::reportSv(GnssSvStatus &svStatus, GpsLocationExtended &locationExtended, void* svExt){ sendMsg(new LocEngReportSv(mLocEngAdapter, svStatus, locationExtended, svExt)); } -void LocEngAdapter::reportSv(QcomSvStatus &svStatus, +void LocEngAdapter::reportSv(GnssSvStatus &svStatus, GpsLocationExtended &locationExtended, void* svExt) { @@ -534,9 +534,8 @@ enum loc_api_adapter_err LocEngAdapter::setTime(GpsUtcTime time, if (mSupportsTimeInjection) { LOC_LOGD("%s:%d]: Injecting time", __func__, __LINE__); result = mLocApi->setTime(time, timeReference, uncertainty); - } else { - mSupportsTimeInjection = true; } + return result; } @@ -566,10 +565,10 @@ enum loc_api_adapter_err LocEngAdapter::setXtraVersionCheck(int check) return ret; } -void LocEngAdapter::reportGpsMeasurementData(GpsData &gpsMeasurementData) +void LocEngAdapter::reportGnssMeasurementData(GnssData &gnssMeasurementData) { - sendMsg(new LocEngReportGpsMeasurement(mOwner, - gpsMeasurementData)); + sendMsg(new LocEngReportGnssMeasurement(mOwner, + gnssMeasurementData)); } /* diff --git a/gps/loc_api/libloc_api_50001/LocEngAdapter.h b/gps/loc_api/libloc_api_50001/LocEngAdapter.h index 8964ede..76d0129 100644 --- a/gps/loc_api/libloc_api_50001/LocEngAdapter.h +++ b/gps/loc_api/libloc_api_50001/LocEngAdapter.h @@ -1,4 +1,4 @@ -/* Copyright (c) 2011-2015, The Linux Foundation. All rights reserved. +/* Copyright (c) 2011-2016, The Linux Foundation. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are @@ -55,7 +55,7 @@ public: void* locationExt, enum loc_sess_status status, LocPosTechMask loc_technology_mask); - virtual void reportSv(QcomSvStatus &svStatus, + virtual void reportSv(GnssSvStatus &svStatus, GpsLocationExtended &locationExtended, void* svExt); virtual void reportStatus(GpsStatusValue status); @@ -85,6 +85,7 @@ public: bool mSupportsAgpsRequests; bool mSupportsPositionInjection; bool mSupportsTimeInjection; + GnssSystemInfo mGnssInfo; LocEngAdapter(LOC_API_ADAPTER_EVENT_MASK_T mask, void* owner, ContextBase* context, @@ -105,6 +106,9 @@ public: inline bool hasCPIExtendedCapabilities() { return mContext->hasCPIExtendedCapabilities(); } + inline bool hasNativeXtraClient() { + return mContext->hasNativeXtraClient(); + } inline const MsgTask* getMsgTask() { return mMsgTask; } inline enum loc_api_adapter_err @@ -186,6 +190,11 @@ public: { return mLocApi->setSUPLVersion(version); } + inline enum loc_api_adapter_err + setNMEATypes (uint32_t typesMask) + { + return mLocApi->setNMEATypes(typesMask); + } inline enum loc_api_adapter_err setLPPConfig(uint32_t profile) { @@ -221,16 +230,16 @@ public: gyroSamplesPerBatchHigh, gyroBatchesPerSecHigh, algorithmConfig); } - inline virtual enum loc_api_adapter_err - setExtPowerConfig(int isBatteryCharging) - { - return mLocApi->setExtPowerConfig(isBatteryCharging); - } inline virtual enum loc_api_adapter_err setAGLONASSProtocol(unsigned long aGlonassProtocol) { return mLocApi->setAGLONASSProtocol(aGlonassProtocol); } + inline virtual enum loc_api_adapter_err + setLPPeProtocol(unsigned long lppeCP, unsigned long lppeUP) + { + return mLocApi->setLPPeProtocol(lppeCP, lppeUP); + } inline virtual int initDataServiceClient() { return mLocApi->initDataServiceClient(); @@ -269,7 +278,7 @@ public: void* locationExt, enum loc_sess_status status, LocPosTechMask loc_technology_mask); - virtual void reportSv(QcomSvStatus &svStatus, + virtual void reportSv(GnssSvStatus &svStatus, GpsLocationExtended &locationExtended, void* svExt); virtual void reportStatus(GpsStatusValue status); @@ -284,7 +293,7 @@ public: virtual bool requestSuplES(int connHandle); virtual bool reportDataCallOpened(); virtual bool reportDataCallClosed(); - virtual void reportGpsMeasurementData(GpsData &gpsMeasurementData); + virtual void reportGnssMeasurementData(GnssData &gnssMeasurementData); inline const LocPosMode& getPositionMode() const {return mFixCriteria;} diff --git a/gps/loc_api/libloc_api_50001/loc.cpp b/gps/loc_api/libloc_api_50001/loc.cpp index 505fc94..f9c43ab 100644 --- a/gps/loc_api/libloc_api_50001/loc.cpp +++ b/gps/loc_api/libloc_api_50001/loc.cpp @@ -1,4 +1,4 @@ -/* Copyright (c) 2011-2015, The Linux Foundation. All rights reserved. +/* Copyright (c) 2011-2016, The Linux Foundation. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are @@ -52,9 +52,15 @@ using namespace loc_core; //Globals defns static gps_location_callback gps_loc_cb = NULL; static gps_sv_status_callback gps_sv_cb = NULL; +static gps_ni_notify_callback gps_ni_cb = NULL; static void local_loc_cb(UlpLocation* location, void* locExt); static void local_sv_cb(GpsSvStatus* sv_status, void* svExt); +static void local_ni_cb(GpsNiNotification *notification, bool esEnalbed); + +GpsNiExtCallbacks sGpsNiExtCallbacks = { + local_ni_cb +}; static const GpsGeofencingInterface* get_geofence_interface(void); @@ -285,6 +291,7 @@ static int loc_init(GpsCallbacks* callbacks) } event = LOC_API_ADAPTER_BIT_PARSED_POSITION_REPORT | + LOC_API_ADAPTER_BIT_GNSS_MEASUREMENT | LOC_API_ADAPTER_BIT_SATELLITE_REPORT | LOC_API_ADAPTER_BIT_LOCATION_SERVER_REQUEST | LOC_API_ADAPTER_BIT_ASSISTANCE_DATA_REQUEST | @@ -304,6 +311,8 @@ static int loc_init(GpsCallbacks* callbacks) NULL, /* location_ext_parser */ NULL, /* sv_ext_parser */ callbacks->request_utc_time_cb, /* request_utc_time_cb */ + callbacks->set_system_info_cb, /* set_system_info_cb */ + callbacks->gnss_sv_status_cb, /* gnss_sv_status_cb */ }; gps_loc_cb = callbacks->location_cb; @@ -312,9 +321,10 @@ static int loc_init(GpsCallbacks* callbacks) retVal = loc_eng_init(loc_afw_data, &clientCallbacks, event, NULL); loc_afw_data.adapter->mSupportsAgpsRequests = !loc_afw_data.adapter->hasAgpsExtendedCapabilities(); loc_afw_data.adapter->mSupportsPositionInjection = !loc_afw_data.adapter->hasCPIExtendedCapabilities(); - loc_afw_data.adapter->mSupportsTimeInjection = !loc_afw_data.adapter->hasCPIExtendedCapabilities(); + loc_afw_data.adapter->mSupportsTimeInjection = !loc_afw_data.adapter->hasCPIExtendedCapabilities() + && !loc_afw_data.adapter->hasNativeXtraClient(); loc_afw_data.adapter->setGpsLockMsg(0); - loc_afw_data.adapter->requestUlp(getCarrierCapabilities()); + loc_afw_data.adapter->requestUlp(ContextBase::getCarrierCapabilities()); loc_afw_data.adapter->setXtraUserAgent(); if(retVal) { @@ -538,7 +548,10 @@ SIDE EFFECTS static void loc_delete_aiding_data(GpsAidingData f) { ENTRY_LOG(); + +#ifndef TARGET_BUILD_VARIANT_USER loc_eng_delete_aiding_data(loc_afw_data, f); +#endif EXIT_LOG(%s, VOID_RET); } @@ -730,7 +743,7 @@ static int loc_agps_open_with_apniptype(const char* apn, ApnIpType apnIpType) bearerType = AGPS_APN_BEARER_IPV4V6; break; default: - bearerType = AGPS_APN_BEARER_INVALID; + bearerType = AGPS_APN_BEARER_IPV4; break; } @@ -960,7 +973,8 @@ SIDE EFFECTS void loc_ni_init(GpsNiCallbacks *callbacks) { ENTRY_LOG(); - loc_eng_ni_init(loc_afw_data,(GpsNiExtCallbacks*) callbacks); + gps_ni_cb = callbacks->notify_cb; + loc_eng_ni_init(loc_afw_data, &sGpsNiExtCallbacks); EXIT_LOG(%s, VOID_RET); } @@ -1075,3 +1089,10 @@ static void local_sv_cb(GpsSvStatus* sv_status, void* svExt) EXIT_LOG(%s, VOID_RET); } +static void local_ni_cb(GpsNiNotification *notification, bool esEnalbed) +{ + if (NULL != gps_ni_cb) { + gps_ni_cb(notification); + } +} + diff --git a/gps/loc_api/libloc_api_50001/loc.h b/gps/loc_api/libloc_api_50001/loc.h index e56fdcf..02ca538 100644 --- a/gps/loc_api/libloc_api_50001/loc.h +++ b/gps/loc_api/libloc_api_50001/loc.h @@ -57,6 +57,8 @@ typedef struct { loc_ext_parser location_ext_parser; loc_ext_parser sv_ext_parser; gps_request_utc_time request_utc_time_cb; + gnss_set_system_info set_system_info_cb; + gnss_sv_status_callback gnss_sv_status_cb; } LocCallbacks; #ifdef __cplusplus diff --git a/gps/loc_api/libloc_api_50001/loc_eng.cpp b/gps/loc_api/libloc_api_50001/loc_eng.cpp index 23baa27..1d83ccb 100644 --- a/gps/loc_api/libloc_api_50001/loc_eng.cpp +++ b/gps/loc_api/libloc_api_50001/loc_eng.cpp @@ -1,4 +1,4 @@ -/* Copyright (c) 2009-2015, The Linux Foundation. All rights reserved. +/* Copyright (c) 2009-2016, The Linux Foundation. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are @@ -90,8 +90,6 @@ using namespace loc_core; boolean configAlreadyRead = false; unsigned int agpsStatus = 0; -loc_gps_cfg_s_type gps_conf; -loc_sap_cfg_s_type sap_conf; /* Parameter spec table */ static const loc_param_s_type gps_conf_table[] = @@ -100,8 +98,11 @@ static const loc_param_s_type gps_conf_table[] = {"SUPL_VER", &gps_conf.SUPL_VER, NULL, 'n'}, {"LPP_PROFILE", &gps_conf.LPP_PROFILE, NULL, 'n'}, {"A_GLONASS_POS_PROTOCOL_SELECT", &gps_conf.A_GLONASS_POS_PROTOCOL_SELECT, NULL, 'n'}, + {"LPPE_CP_TECHNOLOGY", &gps_conf.LPPE_CP_TECHNOLOGY, NULL, 'n'}, + {"LPPE_UP_TECHNOLOGY", &gps_conf.LPPE_UP_TECHNOLOGY, NULL, 'n'}, {"AGPS_CERT_WRITABLE_MASK", &gps_conf.AGPS_CERT_WRITABLE_MASK, NULL, 'n'}, {"SUPL_MODE", &gps_conf.SUPL_MODE, NULL, 'n'}, + {"SUPL_ES", &gps_conf.SUPL_ES, NULL, 'n'}, {"INTERMEDIATE_POS", &gps_conf.INTERMEDIATE_POS, NULL, 'n'}, {"ACCURACY_THRES", &gps_conf.ACCURACY_THRES, NULL, 'n'}, {"NMEA_PROVIDER", &gps_conf.NMEA_PROVIDER, NULL, 'n'}, @@ -143,6 +144,7 @@ static void loc_default_parameters(void) gps_conf.GPS_LOCK = 0; gps_conf.SUPL_VER = 0x10000; gps_conf.SUPL_MODE = 0x3; + gps_conf.SUPL_ES = 0; gps_conf.CAPABILITIES = 0x7; /* LTE Positioning Profile configuration is disable by default*/ gps_conf.LPP_PROFILE = 0; @@ -152,6 +154,10 @@ static void loc_default_parameters(void) gps_conf.XTRA_VERSION_CHECK=0; /*Use emergency PDN by default*/ gps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL = 1; + /* By default no LPPe CP technology is enabled*/ + gps_conf.LPPE_CP_TECHNOLOGY = 0; + /* By default no LPPe UP technology is enabled*/ + gps_conf.LPPE_UP_TECHNOLOGY = 0; /*Defaults for sap.conf*/ sap_conf.GYRO_BIAS_RANDOM_WALK = 0; @@ -208,6 +214,7 @@ static int loc_eng_get_zpp_handler(loc_eng_data_s_type &loc_eng_data); static void deleteAidingData(loc_eng_data_s_type &logEng); static AgpsStateMachine* getAgpsStateMachine(loc_eng_data_s_type& logEng, AGpsExtType agpsType); +static void createAgnssNifs(loc_eng_data_s_type& locEng); static int dataCallCb(void *cb_data); static void update_aiding_data_for_deletion(loc_eng_data_s_type& loc_eng_data) { if (loc_eng_data.engine_status != GPS_STATUS_ENGINE_ON && @@ -470,6 +477,29 @@ struct LocEngAGlonassProtocol : public LocMsg { } }; + +struct LocEngLPPeProtocol : public LocMsg { + LocEngAdapter* mAdapter; + const unsigned long mLPPeCP; + const unsigned long mLPPeUP; + inline LocEngLPPeProtocol(LocEngAdapter* adapter, + unsigned long lppeCP, unsigned long lppeUP) : + LocMsg(), mAdapter(adapter), mLPPeCP(lppeCP), mLPPeUP(lppeUP) + { + locallog(); + } + inline virtual void proc() const { + mAdapter->setLPPeProtocol(mLPPeCP, mLPPeUP); + } + inline void locallog() const { + LOC_LOGV("LPPe CP: 0x%lx LPPe UP: 0x%1x", mLPPeCP, mLPPeUP); + } + inline virtual void log() const { + locallog(); + } +}; + + // case LOC_ENG_MSG_SUPL_VERSION: struct LocEngSuplVer : public LocMsg { LocEngAdapter* mAdapter; @@ -500,7 +530,7 @@ struct LocEngSuplMode : public LocMsg { locallog(); } inline virtual void proc() const { - mUlp->setCapabilities(getCarrierCapabilities()); + mUlp->setCapabilities(ContextBase::getCarrierCapabilities()); } inline void locallog() const { } @@ -509,6 +539,31 @@ struct LocEngSuplMode : public LocMsg { } }; +// case LOC_ENG_MSG_SET_NMEA_TYPE: +struct LocEngSetNmeaTypes : public LocMsg { + LocEngAdapter* mAdapter; + uint32_t nmeaTypesMask; + inline LocEngSetNmeaTypes(LocEngAdapter* adapter, + uint32_t typesMask) : + LocMsg(), mAdapter(adapter), nmeaTypesMask(typesMask) + { + locallog(); + } + inline virtual void proc() const { + // set the nmea types + mAdapter->setNMEATypes(nmeaTypesMask); + } + inline void locallog() const + { + LOC_LOGV("LocEngSetNmeaTypes %u\n",nmeaTypesMask); + } + inline virtual void log() const + { + locallog(); + } +}; + + // case LOC_ENG_MSG_LPP_CONFIG: struct LocEngLppConfig : public LocMsg { LocEngAdapter* mAdapter; @@ -699,29 +754,6 @@ struct LocEngSensorPerfControlConfig : public LocMsg { } }; -// case LOC_ENG_MSG_EXT_POWER_CONFIG: -struct LocEngExtPowerConfig : public LocMsg { - LocEngAdapter* mAdapter; - const int mIsBatteryCharging; - inline LocEngExtPowerConfig(LocEngAdapter* adapter, - int isBatteryCharging) : - LocMsg(), mAdapter(adapter), - mIsBatteryCharging(isBatteryCharging) - { - locallog(); - } - inline virtual void proc() const { - mAdapter->setExtPowerConfig(mIsBatteryCharging); - } - inline void locallog() const { - LOC_LOGV("LocEngExtPowerConfig - isBatteryCharging: %d", - mIsBatteryCharging); - } - inline virtual void log() const { - locallog(); - } -}; - // case LOC_ENG_MSG_REPORT_POSITION: LocEngReportPosition::LocEngReportPosition(LocAdapterBase* adapter, UlpLocation &loc, @@ -828,7 +860,7 @@ void LocEngReportPosition::send() const { // case LOC_ENG_MSG_REPORT_SV: LocEngReportSv::LocEngReportSv(LocAdapterBase* adapter, - QcomSvStatus &sv, + GnssSvStatus &sv, GpsLocationExtended &locExtended, void* svExt) : LocMsg(), mAdapter(adapter), mSvStatus(sv), @@ -845,9 +877,9 @@ void LocEngReportSv::proc() const { if (locEng->mute_session_state != LOC_MUTE_SESS_IN_SESSION) { - if (locEng->sv_status_cb != NULL) { - locEng->sv_status_cb((GpsSvStatus*)&(mSvStatus), - (void*)mSvExt); + if (locEng->gnss_sv_status_cb != NULL) { + LOC_LOGE("Calling gnss_sv_status_cb"); + locEng->gnss_sv_status_cb((GnssSvStatus*)&(mSvStatus)); } if (locEng->generateNmea) @@ -1089,7 +1121,7 @@ LocEngRequestSuplEs::LocEngRequestSuplEs(void* locEng, int id) : } void LocEngRequestSuplEs::proc() const { loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng; - if (locEng->ds_nif) { + if (locEng->ds_nif && gps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL) { AgpsStateMachine* sm = locEng->ds_nif; DSSubscriber s(sm, mID); sm->subscribeRsrc((Subscriber*)&s); @@ -1213,16 +1245,7 @@ LocEngReqRelWifi::~LocEngReqRelWifi() { } void LocEngReqRelWifi::proc() const { loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng; - if (locEng->wifi_nif) { - WIFISubscriber s(locEng->wifi_nif, mSSID, mPassword, mSenderId); - if (mIsReq) { - locEng->wifi_nif->subscribeRsrc((Subscriber*)&s); - } else { - locEng->wifi_nif->unsubscribeRsrc((Subscriber*)&s); - } - } else { - locEng->adapter->atlOpenStatus(mSenderId, 0, NULL, -1, mType); - } + locEng->adapter->atlOpenStatus(mSenderId, 0, NULL, -1, mType); } inline void LocEngReqRelWifi::locallog() const { LOC_LOGV("%s - senderId: %d, ssid: %s, password: %s", @@ -1376,6 +1399,32 @@ struct LocEngSetCapabilities : public LocMsg { } }; +struct LocEngSetSystemInfo : public LocMsg { + loc_eng_data_s_type* mLocEng; + inline LocEngSetSystemInfo(loc_eng_data_s_type* locEng) : + LocMsg(), mLocEng(locEng) + { + locallog(); + } + inline virtual void proc() const { + if (NULL != mLocEng->set_system_info_cb) { + LOC_LOGV("calling set_system_info_cb 0x%x", + mLocEng->adapter->mGnssInfo.year_of_hw); + mLocEng->set_system_info_cb(&(mLocEng->adapter->mGnssInfo)); + } + else { + LOC_LOGV("set_system_info_cb is NULL.\n"); + } + } + inline void locallog() const + { + LOC_LOGV("LocEngSetSystemInfo"); + } + inline virtual void log() const + { + locallog(); + } +}; // case LOC_ENG_MSG_LOC_INIT: struct LocEngInit : public LocMsg { loc_eng_data_s_type* mLocEng; @@ -1388,6 +1437,7 @@ struct LocEngInit : public LocMsg { loc_eng_reinit(*mLocEng); // set the capabilities mLocEng->adapter->sendMsg(new LocEngSetCapabilities(mLocEng)); + mLocEng->adapter->sendMsg(new LocEngSetSystemInfo(mLocEng)); } inline void locallog() const { @@ -1404,16 +1454,18 @@ struct LocEngInit : public LocMsg { // case LOC_ENG_MSG_ATL_OPEN_SUCCESS: struct LocEngAtlOpenSuccess : public LocMsg { - AgpsStateMachine* mStateMachine; + loc_eng_data_s_type* mLocEng; + const AGpsExtType mAgpsType; const int mLen; char* mAPN; const AGpsBearerType mBearerType; - inline LocEngAtlOpenSuccess(AgpsStateMachine* statemachine, + inline LocEngAtlOpenSuccess(loc_eng_data_s_type* locEng, + const AGpsExtType agpsType, const char* name, int len, AGpsBearerType btype) : LocMsg(), - mStateMachine(statemachine), mLen(len), + mLocEng(locEng), mAgpsType(agpsType), mLen(len), mAPN(new char[len+1]), mBearerType(btype) { memcpy((void*)mAPN, (void*)name, len); @@ -1425,14 +1477,15 @@ struct LocEngAtlOpenSuccess : public LocMsg { delete[] mAPN; } inline virtual void proc() const { - mStateMachine->setBearer(mBearerType); - mStateMachine->setAPN(mAPN, mLen); - mStateMachine->onRsrcEvent(RSRC_GRANTED); + AgpsStateMachine* sm = getAgpsStateMachine(*mLocEng, mAgpsType); + sm->setBearer(mBearerType); + sm->setAPN(mAPN, mLen); + sm->onRsrcEvent(RSRC_GRANTED); } inline void locallog() const { LOC_LOGV("LocEngAtlOpenSuccess agps type: %s\n apn: %s\n" " bearer type: %s", - loc_get_agps_type_name(mStateMachine->getType()), + loc_get_agps_type_name(mAgpsType), mAPN, loc_get_agps_bear_name(mBearerType)); } @@ -1443,13 +1496,16 @@ struct LocEngAtlOpenSuccess : public LocMsg { // case LOC_ENG_MSG_ATL_CLOSED: struct LocEngAtlClosed : public LocMsg { - AgpsStateMachine* mStateMachine; - inline LocEngAtlClosed(AgpsStateMachine* statemachine) : - LocMsg(), mStateMachine(statemachine) { + loc_eng_data_s_type* mLocEng; + const AGpsExtType mAgpsType; + inline LocEngAtlClosed(loc_eng_data_s_type* locEng, + const AGpsExtType agpsType) : + LocMsg(), mLocEng(locEng), mAgpsType(agpsType) { locallog(); } inline virtual void proc() const { - mStateMachine->onRsrcEvent(RSRC_RELEASED); + AgpsStateMachine* sm = getAgpsStateMachine(*mLocEng, mAgpsType); + sm->onRsrcEvent(RSRC_RELEASED); } inline void locallog() const { LOC_LOGV("LocEngAtlClosed"); @@ -1461,13 +1517,16 @@ struct LocEngAtlClosed : public LocMsg { // case LOC_ENG_MSG_ATL_OPEN_FAILED: struct LocEngAtlOpenFailed : public LocMsg { - AgpsStateMachine* mStateMachine; - inline LocEngAtlOpenFailed(AgpsStateMachine* statemachine) : - LocMsg(), mStateMachine(statemachine) { + loc_eng_data_s_type* mLocEng; + const AGpsExtType mAgpsType; + inline LocEngAtlOpenFailed(loc_eng_data_s_type* locEng, + const AGpsExtType agpsType) : + LocMsg(), mLocEng(locEng), mAgpsType(agpsType) { locallog(); } inline virtual void proc() const { - mStateMachine->onRsrcEvent(RSRC_DENIED); + AgpsStateMachine* sm = getAgpsStateMachine(*mLocEng, mAgpsType); + sm->onRsrcEvent(RSRC_DENIED); } inline void locallog() const { LOC_LOGV("LocEngAtlOpenFailed"); @@ -1509,22 +1568,17 @@ inline void LocEngUp::log() const { locallog(); } -struct LocEngDataClientInit : public LocMsg { +struct LocEngAgnssNifInit : public LocMsg { loc_eng_data_s_type* mLocEng; - inline LocEngDataClientInit(loc_eng_data_s_type* locEng) : + inline LocEngAgnssNifInit(loc_eng_data_s_type* locEng) : LocMsg(), mLocEng(locEng) { locallog(); } virtual void proc() const { - loc_eng_data_s_type *locEng = (loc_eng_data_s_type *)mLocEng; - if(!locEng->adapter->initDataServiceClient()) { - locEng->ds_nif = new DSStateMachine(servicerTypeExt, - (void *)dataCallCb, - locEng->adapter); - } + createAgnssNifs(*mLocEng); } void locallog() const { - LOC_LOGV("LocEngDataClientInit\n"); + LOC_LOGV("LocEngAgnssNifInit\n"); } virtual void log() const { locallog(); @@ -1607,10 +1661,13 @@ struct LocEngGnssConstellationConfig : public LocMsg { locallog(); } inline virtual void proc() const { + mAdapter->mGnssInfo.size = sizeof(GnssSystemInfo); if (mAdapter->gnssConstellationConfig()) { LOC_LOGV("Modem supports GNSS measurements\n"); gps_conf.CAPABILITIES |= GPS_CAPABILITY_MEASUREMENTS; + mAdapter->mGnssInfo.year_of_hw = 2016; } else { + mAdapter->mGnssInfo.year_of_hw = 2015; LOC_LOGV("Modem does not support GNSS measurements\n"); } } @@ -1623,50 +1680,59 @@ struct LocEngGnssConstellationConfig : public LocMsg { }; // case LOC_ENG_MSG_REPORT_GNSS_MEASUREMENT: -LocEngReportGpsMeasurement::LocEngReportGpsMeasurement(void* locEng, - GpsData &gpsData) : - LocMsg(), mLocEng(locEng), mGpsData(gpsData) +LocEngReportGnssMeasurement::LocEngReportGnssMeasurement(void* locEng, + GnssData &gnssData) : + LocMsg(), mLocEng(locEng), mGnssData(gnssData) { locallog(); } -void LocEngReportGpsMeasurement::proc() const { +void LocEngReportGnssMeasurement::proc() const { loc_eng_data_s_type* locEng = (loc_eng_data_s_type*) mLocEng; if (locEng->mute_session_state != LOC_MUTE_SESS_IN_SESSION) { - if (locEng->gps_measurement_cb != NULL) { - locEng->gps_measurement_cb((GpsData*)&(mGpsData)); + if (locEng->gnss_measurement_cb != NULL) { + LOC_LOGV("Calling gnss_measurement_cb"); + locEng->gnss_measurement_cb((GnssData*)&(mGnssData)); } } } -void LocEngReportGpsMeasurement::locallog() const { +void LocEngReportGnssMeasurement::locallog() const { IF_LOC_LOGV { LOC_LOGV("%s:%d]: Received in GPS HAL." "GNSS Measurements count: %d \n", - __func__, __LINE__, mGpsData.measurement_count); - for (int i =0; i< mGpsData.measurement_count && i < GPS_MAX_SVS; i++) { + __func__, __LINE__, mGnssData.measurement_count); + for (int i =0; i< mGnssData.measurement_count && i < GNSS_MAX_SVS; i++) { LOC_LOGV(" GNSS measurement data in GPS HAL: \n" - " GPS_HAL => Measurement ID | prn | time_offset_ns | state |" - " received_gps_tow_ns| c_n0_dbhz | pseudorange_rate_mps |" + " GPS_HAL => Measurement ID | svid | time_offset_ns | state |" + " c_n0_dbhz | pseudorange_rate_mps |" " pseudorange_rate_uncertainty_mps |" " accumulated_delta_range_state | flags \n" - " GPS_HAL => %d | %d | %f | %d | %lld | %f | %f | %f | %d | %d \n", + " GPS_HAL => %d | %d | %f | %d | %f | %f | %f | %d | %d \n", i, - mGpsData.measurements[i].prn, - mGpsData.measurements[i].time_offset_ns, - mGpsData.measurements[i].state, - mGpsData.measurements[i].received_gps_tow_ns, - mGpsData.measurements[i].c_n0_dbhz, - mGpsData.measurements[i].pseudorange_rate_mps, - mGpsData.measurements[i].pseudorange_rate_uncertainty_mps, - mGpsData.measurements[i].accumulated_delta_range_state, - mGpsData.measurements[i].flags); + mGnssData.measurements[i].svid, + mGnssData.measurements[i].time_offset_ns, + mGnssData.measurements[i].state, + mGnssData.measurements[i].c_n0_dbhz, + mGnssData.measurements[i].pseudorange_rate_mps, + mGnssData.measurements[i].pseudorange_rate_uncertainty_mps, + mGnssData.measurements[i].accumulated_delta_range_state, + mGnssData.measurements[i].flags); } - LOC_LOGV(" GPS_HAL => Clocks Info: type | time_ns \n" - " GPS_HAL => Clocks Info: %d | %lld", mGpsData.clock.type, - mGpsData.clock.time_ns); + LOC_LOGV(" GPS_HAL => Clocks Info: \n" + " time_ns | full_bias_ns | bias_ns | bias_uncertainty_ns | " + " drift_nsps | drift_uncertainty_nsps | hw_clock_discontinuity_count | flags" + " GPS_HAL => Clocks Info: %lld | %lld | %g | %g | %g | %g | %d | 0x%04x\n", + mGnssData.clock.time_ns, + mGnssData.clock.full_bias_ns, + mGnssData.clock.bias_ns, + mGnssData.clock.bias_uncertainty_ns, + mGnssData.clock.drift_nsps, + mGnssData.clock.drift_uncertainty_nsps, + mGnssData.clock.hw_clock_discontinuity_count, + mGnssData.clock.flags); } } -inline void LocEngReportGpsMeasurement::log() const { +inline void LocEngReportGnssMeasurement::log() const { locallog(); } @@ -1683,24 +1749,6 @@ inline void LocEngReportGpsMeasurement::log() const { } #define INIT_CHECK(ctx, ret) STATE_CHECK(ctx, "instance not initialized", ret) -uint32_t getCarrierCapabilities() { - #define carrierMSA (uint32_t)0x2 - #define carrierMSB (uint32_t)0x1 - #define gpsConfMSA (uint32_t)0x4 - #define gpsConfMSB (uint32_t)0x2 - uint32_t capabilities = gps_conf.CAPABILITIES; - if ((gps_conf.SUPL_MODE & carrierMSA) != carrierMSA) { - capabilities &= ~gpsConfMSA; - } - if ((gps_conf.SUPL_MODE & carrierMSB) != carrierMSB) { - capabilities &= ~gpsConfMSB; - } - - LOC_LOGV("getCarrierCapabilities: CAPABILITIES %x, SUPL_MODE %x, carrier capabilities %x", - gps_conf.CAPABILITIES, gps_conf.SUPL_MODE, capabilities); - return capabilities; -} - /*=========================================================================== FUNCTION loc_eng_init @@ -1746,6 +1794,8 @@ int loc_eng_init(loc_eng_data_s_type &loc_eng_data, LocCallbacks* callbacks, loc_eng_data.acquire_wakelock_cb = callbacks->acquire_wakelock_cb; loc_eng_data.release_wakelock_cb = callbacks->release_wakelock_cb; loc_eng_data.request_utc_time_cb = callbacks->request_utc_time_cb; + loc_eng_data.set_system_info_cb = callbacks->set_system_info_cb; + loc_eng_data.gnss_sv_status_cb = callbacks->gnss_sv_status_cb; loc_eng_data.location_ext_parser = callbacks->location_ext_parser ? callbacks->location_ext_parser : noProc; loc_eng_data.sv_ext_parser = callbacks->sv_ext_parser ? @@ -1761,7 +1811,7 @@ int loc_eng_init(loc_eng_data_s_type &loc_eng_data, LocCallbacks* callbacks, event = event ^ LOC_API_ADAPTER_BIT_NMEA_1HZ_REPORT; // unregister for modem NMEA report loc_eng_data.generateNmea = true; } - else + else if (gps_conf.NMEA_PROVIDER == NMEA_PROVIDER_MP) { loc_eng_data.generateNmea = false; } @@ -1770,6 +1820,8 @@ int loc_eng_init(loc_eng_data_s_type &loc_eng_data, LocCallbacks* callbacks, new LocEngAdapter(event, &loc_eng_data, context, (LocThread::tCreate)callbacks->create_thread_cb); + loc_eng_data.adapter->mGnssInfo.size = sizeof(GnssSystemInfo); + loc_eng_data.adapter->mGnssInfo.year_of_hw = 2015; LOC_LOGD("loc_eng_init created client, id = %p\n", loc_eng_data.adapter); loc_eng_data.adapter->sendMsg(new LocEngInit(&loc_eng_data)); @@ -1790,6 +1842,15 @@ static int loc_eng_reinit(loc_eng_data_s_type &loc_eng_data) adapter->sendMsg(new LocEngSensorControlConfig(adapter, sap_conf.SENSOR_USAGE, sap_conf.SENSOR_PROVIDER)); adapter->sendMsg(new LocEngAGlonassProtocol(adapter, gps_conf.A_GLONASS_POS_PROTOCOL_SELECT)); + adapter->sendMsg(new LocEngLPPeProtocol(adapter, gps_conf.LPPE_CP_TECHNOLOGY, + gps_conf.LPPE_UP_TECHNOLOGY)); + + if (!loc_eng_data.generateNmea) + { + NmeaSentenceTypesMask typesMask = LOC_NMEA_ALL_SUPPORTED_MASK; + LOC_LOGD("loc_eng_init setting nmea types, mask = %u\n",typesMask); + adapter->sendMsg(new LocEngSetNmeaTypes(adapter,typesMask)); + } /* Make sure at least one of the sensor property is specified by the user in the gps.conf file. */ if( sap_conf.GYRO_BIAS_RANDOM_WALK_VALID || @@ -1974,7 +2035,6 @@ static int loc_eng_stop_handler(loc_eng_data_s_type &loc_eng_data) int ret_val = LOC_API_ADAPTER_ERR_SUCCESS; if (loc_eng_data.adapter->isInSession()) { - ret_val = loc_eng_data.adapter->stopFix(); loc_eng_data.adapter->setInSession(FALSE); } @@ -2296,28 +2356,9 @@ void loc_eng_agps_init(loc_eng_data_s_type &loc_eng_data, AGpsExtCallbacks* call LocEngAdapter* adapter = loc_eng_data.adapter; loc_eng_data.agps_status_cb = callbacks->status_cb; - loc_eng_data.internet_nif = new AgpsStateMachine(servicerTypeAgps, - (void *)loc_eng_data.agps_status_cb, - AGPS_TYPE_WWAN_ANY, - false); - loc_eng_data.wifi_nif = new AgpsStateMachine(servicerTypeAgps, - (void *)loc_eng_data.agps_status_cb, - AGPS_TYPE_WIFI, - true); - - if ((gps_conf.CAPABILITIES & GPS_CAPABILITY_MSA) || - (gps_conf.CAPABILITIES & GPS_CAPABILITY_MSB)) { - loc_eng_data.agnss_nif = new AgpsStateMachine(servicerTypeAgps, - (void *)loc_eng_data.agps_status_cb, - AGPS_TYPE_SUPL, - false); - + if (NULL != adapter) { if (adapter->mSupportsAgpsRequests) { - if(gps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL) { - loc_eng_data.adapter->sendMsg(new LocEngDataClientInit(&loc_eng_data)); - } - loc_eng_dmn_conn_loc_api_server_launch(callbacks->create_thread_cb, - NULL, NULL, &loc_eng_data); + adapter->sendMsg(new LocEngAgnssNifInit(&loc_eng_data)); } loc_eng_agps_reinit(loc_eng_data); } @@ -2333,23 +2374,55 @@ static void deleteAidingData(loc_eng_data_s_type &logEng) { } } +// must be called under msg handler context +static void createAgnssNifs(loc_eng_data_s_type& locEng) { + bool agpsCapable = ((gps_conf.CAPABILITIES & GPS_CAPABILITY_MSA) || + (gps_conf.CAPABILITIES & GPS_CAPABILITY_MSB)); + LocEngAdapter* adapter = locEng.adapter; + if (NULL != adapter && adapter->mSupportsAgpsRequests) { + if (NULL == locEng.internet_nif) { + locEng.internet_nif= new AgpsStateMachine(servicerTypeAgps, + (void *)locEng.agps_status_cb, + AGPS_TYPE_WWAN_ANY, + false); + } + if (agpsCapable) { + if (NULL == locEng.agnss_nif) { + locEng.agnss_nif = new AgpsStateMachine(servicerTypeAgps, + (void *)locEng.agps_status_cb, + AGPS_TYPE_SUPL, + false); + } + if (NULL == locEng.ds_nif && + gps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL && + 0 == adapter->initDataServiceClient()) { + locEng.ds_nif = new DSStateMachine(servicerTypeExt, + (void *)dataCallCb, + locEng.adapter); + } + } + } +} + +// must be called under msg handler context static AgpsStateMachine* getAgpsStateMachine(loc_eng_data_s_type &locEng, AGpsExtType agpsType) { AgpsStateMachine* stateMachine; switch (agpsType) { - case AGPS_TYPE_WIFI: { - stateMachine = locEng.wifi_nif; - break; - } case AGPS_TYPE_INVALID: case AGPS_TYPE_SUPL: { stateMachine = locEng.agnss_nif; break; } case AGPS_TYPE_SUPL_ES: { - locEng.ds_nif ? - stateMachine = locEng.ds_nif: + if (gps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL) { + if (NULL == locEng.ds_nif) { + createAgnssNifs(locEng); + } + stateMachine = locEng.ds_nif; + } else { stateMachine = locEng.agnss_nif; + } break; } default: @@ -2391,10 +2464,9 @@ int loc_eng_agps_open(loc_eng_data_s_type &loc_eng_data, AGpsExtType agpsType, LOC_LOGD("loc_eng_agps_open APN name = [%s]", apn); int apn_len = smaller_of(strlen (apn), MAX_APN_LEN); - AgpsStateMachine* sm = getAgpsStateMachine(loc_eng_data, agpsType); - loc_eng_data.adapter->sendMsg( - new LocEngAtlOpenSuccess(sm, apn, apn_len, bearerType)); + new LocEngAtlOpenSuccess(&loc_eng_data, agpsType, + apn, apn_len, bearerType)); EXIT_LOG(%d, 0); return 0; @@ -2423,8 +2495,8 @@ int loc_eng_agps_closed(loc_eng_data_s_type &loc_eng_data, AGpsExtType agpsType) INIT_CHECK(loc_eng_data.adapter && loc_eng_data.agps_status_cb, return -1); - AgpsStateMachine* sm = getAgpsStateMachine(loc_eng_data, agpsType); - loc_eng_data.adapter->sendMsg(new LocEngAtlClosed(sm)); + loc_eng_data.adapter->sendMsg(new LocEngAtlClosed(&loc_eng_data, + agpsType)); EXIT_LOG(%d, 0); return 0; @@ -2453,8 +2525,8 @@ int loc_eng_agps_open_failed(loc_eng_data_s_type &loc_eng_data, AGpsExtType agps INIT_CHECK(loc_eng_data.adapter && loc_eng_data.agps_status_cb, return -1); - AgpsStateMachine* sm = getAgpsStateMachine(loc_eng_data, agpsType); - loc_eng_data.adapter->sendMsg(new LocEngAtlOpenFailed(sm)); + loc_eng_data.adapter->sendMsg(new LocEngAtlOpenFailed(&loc_eng_data, + agpsType)); EXIT_LOG(%d, 0); return 0; @@ -2730,12 +2802,20 @@ void loc_eng_configuration_update (loc_eng_data_s_type &loc_eng_data, if (gps_conf_tmp.SUPL_MODE != gps_conf.SUPL_MODE) { adapter->sendMsg(new LocEngSuplMode(adapter->getUlpProxy())); } + // we always update lock mask, this is because if this is dsds device, we would not + // know if modem has switched dds, if so, lock mask may also need to be updated. + // if we have power vote, HAL is on, lock mask 0; else gps_conf.GPS_LOCK. + adapter->setGpsLockMsg(adapter->getPowerVote() ? 0 : gps_conf.GPS_LOCK); } gps_conf_tmp.SUPL_VER = gps_conf.SUPL_VER; gps_conf_tmp.LPP_PROFILE = gps_conf.LPP_PROFILE; gps_conf_tmp.A_GLONASS_POS_PROTOCOL_SELECT = gps_conf.A_GLONASS_POS_PROTOCOL_SELECT; + gps_conf_tmp.SUPL_MODE = gps_conf.SUPL_MODE; + gps_conf_tmp.SUPL_ES = gps_conf.SUPL_ES; gps_conf_tmp.GPS_LOCK = gps_conf.GPS_LOCK; + gps_conf_tmp.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL = + gps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL; gps_conf = gps_conf_tmp; } @@ -2856,8 +2936,9 @@ void loc_eng_handle_engine_up(loc_eng_data_s_type &loc_eng_data) if (loc_eng_data.adapter->isInSession()) { // This sets the copy in adapter to modem loc_eng_data.adapter->setInSession(false); - loc_eng_data.adapter->sendMsg(new LocEngStartFix(loc_eng_data.adapter)); + loc_eng_start_handler(loc_eng_data); } + EXIT_LOG(%s, VOID_RET); } @@ -2941,8 +3022,8 @@ int loc_eng_gps_measurement_init(loc_eng_data_s_type &loc_eng_data, { ENTRY_LOG_CALLFLOW(); - STATE_CHECK((NULL == loc_eng_data.gps_measurement_cb), - "gps measurement already initialized", + STATE_CHECK((NULL == loc_eng_data.gnss_measurement_cb), + "gnss measurement already initialized", return GPS_MEASUREMENT_ERROR_ALREADY_INIT); STATE_CHECK((callbacks != NULL), "callbacks can not be NULL", @@ -2958,7 +3039,7 @@ int loc_eng_gps_measurement_init(loc_eng_data_s_type &loc_eng_data, event, LOC_REGISTRATION_MASK_ENABLED)); // set up the callback - loc_eng_data.gps_measurement_cb = callbacks->measurement_callback; + loc_eng_data.gnss_measurement_cb = callbacks->gnss_measurement_callback; LOC_LOGD ("%s, event masks updated successfully", __func__); return GPS_MEASUREMENT_OPERATION_SUCCESS; @@ -2993,6 +3074,6 @@ void loc_eng_gps_measurement_close(loc_eng_data_s_type &loc_eng_data) event, LOC_REGISTRATION_MASK_DISABLED)); // set up the callback - loc_eng_data.gps_measurement_cb = NULL; + loc_eng_data.gnss_measurement_cb = NULL; EXIT_LOG(%d, 0); } diff --git a/gps/loc_api/libloc_api_50001/loc_eng.h b/gps/loc_api/libloc_api_50001/loc_eng.h index a203e6b..3e52709 100644 --- a/gps/loc_api/libloc_api_50001/loc_eng.h +++ b/gps/loc_api/libloc_api_50001/loc_eng.h @@ -1,4 +1,4 @@ -/* Copyright (c) 2009-2014, The Linux Foundation. All rights reserved. +/* Copyright (c) 2009-2014, 2016 The Linux Foundation. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are @@ -67,7 +67,8 @@ typedef unsigned char boolean; #define FAILURE FALSE #define INVALID_ATL_CONNECTION_HANDLE -1 -#define MAX_XTRA_SERVER_URL_LENGTH 256 +#define gps_conf ContextBase::mGps_conf +#define sap_conf ContextBase::mSap_conf enum loc_nmea_provider_e_type { NMEA_PROVIDER_AP = 0, // Application Processor Provider of NMEA @@ -89,12 +90,14 @@ typedef struct loc_eng_data_s loc_sv_status_cb_ext sv_status_cb; agps_status_extended agps_status_cb; gps_nmea_callback nmea_cb; - gps_ni_notify_callback ni_notify_cb; + loc_ni_notify_callback ni_notify_cb; gps_set_capabilities set_capabilities_cb; gps_acquire_wakelock acquire_wakelock_cb; gps_release_wakelock release_wakelock_cb; gps_request_utc_time request_utc_time_cb; - gps_measurement_callback gps_measurement_cb; + gnss_set_system_info set_system_info_cb; + gnss_sv_status_callback gnss_sv_status_cb; + gnss_measurement_callback gnss_measurement_cb; boolean intermediateFix; AGpsStatusValue agps_status; loc_eng_xtra_data_s_type xtra_module_data; @@ -103,7 +106,6 @@ typedef struct loc_eng_data_s // AGPS state machines AgpsStateMachine* agnss_nif; AgpsStateMachine* internet_nif; - AgpsStateMachine* wifi_nif; //State machine for Data Services AgpsStateMachine* ds_nif; @@ -119,7 +121,8 @@ typedef struct loc_eng_data_s // For nmea generation boolean generateNmea; - uint32_t sv_used_mask; + uint32_t gps_used_mask; + uint32_t glo_used_mask; float hdop; float pdop; float vdop; @@ -139,67 +142,6 @@ typedef struct loc_eng_data_s loc_ext_parser sv_ext_parser; } loc_eng_data_s_type; -/* GPS.conf support */ -/* NOTE: the implementaiton of the parser casts number - fields to 32 bit. To ensure all 'n' fields working, - they must all be 32 bit fields. */ -typedef struct loc_gps_cfg_s -{ - uint32_t INTERMEDIATE_POS; - uint32_t ACCURACY_THRES; - uint32_t SUPL_VER; - uint32_t SUPL_MODE; - uint32_t CAPABILITIES; - uint32_t LPP_PROFILE; - uint32_t XTRA_VERSION_CHECK; - char XTRA_SERVER_1[MAX_XTRA_SERVER_URL_LENGTH]; - char XTRA_SERVER_2[MAX_XTRA_SERVER_URL_LENGTH]; - char XTRA_SERVER_3[MAX_XTRA_SERVER_URL_LENGTH]; - uint32_t USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL; - uint32_t NMEA_PROVIDER; - uint32_t GPS_LOCK; - uint32_t A_GLONASS_POS_PROTOCOL_SELECT; - uint32_t AGPS_CERT_WRITABLE_MASK; -} loc_gps_cfg_s_type; - -/* NOTE: the implementaiton of the parser casts number - fields to 32 bit. To ensure all 'n' fields working, - they must all be 32 bit fields. */ -/* Meanwhile, *_valid fields are 8 bit fields, and 'f' - fields are double. Rigid as they are, it is the - the status quo, until the parsing mechanism is - change, that is. */ -typedef struct -{ - uint8_t GYRO_BIAS_RANDOM_WALK_VALID; - double GYRO_BIAS_RANDOM_WALK; - uint32_t SENSOR_ACCEL_BATCHES_PER_SEC; - uint32_t SENSOR_ACCEL_SAMPLES_PER_BATCH; - uint32_t SENSOR_GYRO_BATCHES_PER_SEC; - uint32_t SENSOR_GYRO_SAMPLES_PER_BATCH; - uint32_t SENSOR_ACCEL_BATCHES_PER_SEC_HIGH; - uint32_t SENSOR_ACCEL_SAMPLES_PER_BATCH_HIGH; - uint32_t SENSOR_GYRO_BATCHES_PER_SEC_HIGH; - uint32_t SENSOR_GYRO_SAMPLES_PER_BATCH_HIGH; - uint32_t SENSOR_CONTROL_MODE; - uint32_t SENSOR_USAGE; - uint32_t SENSOR_ALGORITHM_CONFIG_MASK; - uint8_t ACCEL_RANDOM_WALK_SPECTRAL_DENSITY_VALID; - double ACCEL_RANDOM_WALK_SPECTRAL_DENSITY; - uint8_t ANGLE_RANDOM_WALK_SPECTRAL_DENSITY_VALID; - double ANGLE_RANDOM_WALK_SPECTRAL_DENSITY; - uint8_t RATE_RANDOM_WALK_SPECTRAL_DENSITY_VALID; - double RATE_RANDOM_WALK_SPECTRAL_DENSITY; - uint8_t VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY_VALID; - double VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY; - uint32_t SENSOR_PROVIDER; -} loc_sap_cfg_s_type; - -extern loc_gps_cfg_s_type gps_conf; -extern loc_sap_cfg_s_type sap_conf; - - -uint32_t getCarrierCapabilities(); //loc_eng functions int loc_eng_init(loc_eng_data_s_type &loc_eng_data, diff --git a/gps/loc_api/libloc_api_50001/loc_eng_msg.h b/gps/loc_api/libloc_api_50001/loc_eng_msg.h index 73a71c0..435ffbb 100644 --- a/gps/loc_api/libloc_api_50001/loc_eng_msg.h +++ b/gps/loc_api/libloc_api_50001/loc_eng_msg.h @@ -105,11 +105,11 @@ struct LocEngReportPosition : public LocMsg { struct LocEngReportSv : public LocMsg { LocAdapterBase* mAdapter; - const QcomSvStatus mSvStatus; + const GnssSvStatus mSvStatus; const GpsLocationExtended mLocationExtended; const void* mSvExt; LocEngReportSv(LocAdapterBase* adapter, - QcomSvStatus &sv, + GnssSvStatus &sv, GpsLocationExtended &locExtended, void* svExtended); virtual void proc() const; @@ -289,11 +289,11 @@ struct LocEngGetZpp : public LocMsg { void send() const; }; -struct LocEngReportGpsMeasurement : public LocMsg { +struct LocEngReportGnssMeasurement : public LocMsg { void* mLocEng; - const GpsData mGpsData; - LocEngReportGpsMeasurement(void* locEng, - GpsData &gpsData); + const GnssData mGnssData; + LocEngReportGnssMeasurement(void* locEng, + GnssData &gnssData); virtual void proc() const; void locallog() const; virtual void log() const; diff --git a/gps/loc_api/libloc_api_50001/loc_eng_ni.cpp b/gps/loc_api/libloc_api_50001/loc_eng_ni.cpp index 4597b98..d79e635 100644 --- a/gps/loc_api/libloc_api_50001/loc_eng_ni.cpp +++ b/gps/loc_api/libloc_api_50001/loc_eng_ni.cpp @@ -189,7 +189,7 @@ void loc_eng_ni_request_handler(loc_eng_data_s_type &loc_eng_data, } CALLBACK_LOG_CALLFLOW("ni_notify_cb - id", %d, notif->notification_id); - loc_eng_data.ni_notify_cb((GpsNiNotification*)notif); + loc_eng_data.ni_notify_cb((GpsNiNotification*)notif, gps_conf.SUPL_ES != 0); } EXIT_LOG(%s, VOID_RET); } diff --git a/gps/loc_api/libloc_api_50001/loc_eng_nmea.cpp b/gps/loc_api/libloc_api_50001/loc_eng_nmea.cpp index 239c6d1..c38d0a1 100644 --- a/gps/loc_api/libloc_api_50001/loc_eng_nmea.cpp +++ b/gps/loc_api/libloc_api_50001/loc_eng_nmea.cpp @@ -1,4 +1,4 @@ -/* Copyright (c) 2012, The Linux Foundation. All rights reserved. +/* Copyright (c) 2012, 2016, The Linux Foundation. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are @@ -29,10 +29,6 @@ #define LOG_NDDEBUG 0 #define LOG_TAG "LocSvc_eng_nmea" -#define GPS_PRN_START 1 -#define GPS_PRN_END 32 -#define GLONASS_PRN_START 65 -#define GLONASS_PRN_END 96 #include #include #include @@ -92,8 +88,12 @@ int loc_eng_nmea_put_checksum(char *pNmea, int maxSize) length++; } + // length now contains nmea sentence string length not including $ sign. int checksumLength = snprintf(pNmea,(maxSize-length-1),"*%02X\r\n", checksum); - return (length + checksumLength); + + // total length of nmea sentence is length of nmea sentence inc $ sign plus + // length of checksum (+1 is to cover the $ character in the length). + return (length + checksumLength + 1); } /*=========================================================================== @@ -101,6 +101,12 @@ FUNCTION loc_eng_nmea_generate_pos DESCRIPTION Generate NMEA sentences generated based on position report + Currently below sentences are generated within this function: + - $GPGSA : GPS DOP and active SVs + - $GNGSA : GLONASS DOP and active SVs + - $GPVTG : Track made good and ground speed + - $GPRMC : Recommended minimum navigation information + - $GPGGA : Time, position and fix related data DEPENDENCIES NONE @@ -144,7 +150,7 @@ void loc_eng_nmea_generate_pos(loc_eng_data_s_type *loc_eng_data_p, uint32_t svUsedCount = 0; uint32_t svUsedList[32] = {0}; - uint32_t mask = loc_eng_data_p->sv_used_mask; + uint32_t mask = loc_eng_data_p->gps_used_mask; for (uint8_t i = 1; mask > 0 && svUsedCount < 32; i++) { if (mask & 1) @@ -152,7 +158,7 @@ void loc_eng_nmea_generate_pos(loc_eng_data_s_type *loc_eng_data_p, mask = mask >> 1; } // clear the cache so they can't be used again - loc_eng_data_p->sv_used_mask = 0; + loc_eng_data_p->gps_used_mask = 0; char fixType; if (svUsedCount == 0) @@ -210,6 +216,99 @@ void loc_eng_nmea_generate_pos(loc_eng_data_s_type *loc_eng_data_p, length = loc_eng_nmea_put_checksum(sentence, sizeof(sentence)); loc_eng_nmea_send(sentence, length, loc_eng_data_p); + // ------------------ + // ------$GNGSA------ + // ------------------ + uint32_t gloUsedCount = 0; + uint32_t gloUsedList[32] = {0}; + + // Reset locals for GNGSA sentence generation + pMarker = sentence; + lengthRemaining = sizeof(sentence); + mask = loc_eng_data_p->glo_used_mask; + fixType = '\0'; + + // Parse the glonass sv mask, and fetch glo sv ids + // Mask corresponds to the offset. + // GLONASS SV ids are from 65-96 + const int GLONASS_SV_ID_OFFSET = 64; + for (uint8_t i = 1; mask > 0 && gloUsedCount < 32; i++) + { + if (mask & 1) + gloUsedList[gloUsedCount++] = i + GLONASS_SV_ID_OFFSET; + mask = mask >> 1; + } + // clear the cache so they can't be used again + loc_eng_data_p->glo_used_mask = 0; + + if (gloUsedCount == 0) + fixType = '1'; // no fix + else if (gloUsedCount <= 3) + fixType = '2'; // 2D fix + else + fixType = '3'; // 3D fix + + // Start printing the sentence + // Format: $--GSA,a,x,xx,xx,xx,xx,xx,xx,xx,xx,xx,xx,xx,xx,p.p,h.h,v.v*cc + // GNGSA : for glonass SVs + // a : Mode : A : Automatic, allowed to automatically switch 2D/3D + // x : Fixtype : 1 (no fix), 2 (2D fix), 3 (3D fix) + // xx : 12 SV ID + // p.p : Position DOP (Dilution of Precision) + // h.h : Horizontal DOP + // v.v : Vertical DOP + // cc : Checksum value + length = snprintf(pMarker, lengthRemaining, "$GNGSA,A,%c,", fixType); + + if (length < 0 || length >= lengthRemaining) + { + LOC_LOGE("NMEA Error in string formatting"); + return; + } + pMarker += length; + lengthRemaining -= length; + + // Add first 12 GLONASS satellite IDs + for (uint8_t i = 0; i < 12; i++) + { + if (i < gloUsedCount) + length = snprintf(pMarker, lengthRemaining, "%02d,", gloUsedList[i]); + else + length = snprintf(pMarker, lengthRemaining, ","); + + if (length < 0 || length >= lengthRemaining) + { + LOC_LOGE("NMEA Error in string formatting"); + return; + } + pMarker += length; + lengthRemaining -= length; + } + + // Add the position/horizontal/vertical DOP values + if (locationExtended.flags & GPS_LOCATION_EXTENDED_HAS_DOP) + { // dop is in locationExtended, (QMI) + length = snprintf(pMarker, lengthRemaining, "%.1f,%.1f,%.1f", + locationExtended.pdop, + locationExtended.hdop, + locationExtended.vdop); + } + else if (loc_eng_data_p->pdop > 0 && loc_eng_data_p->hdop > 0 && loc_eng_data_p->vdop > 0) + { // dop was cached from sv report (RPC) + length = snprintf(pMarker, lengthRemaining, "%.1f,%.1f,%.1f", + loc_eng_data_p->pdop, + loc_eng_data_p->hdop, + loc_eng_data_p->vdop); + } + else + { // no dop + length = snprintf(pMarker, lengthRemaining, ",,"); + } + + /* Sentence is ready, add checksum and broadcast */ + length = loc_eng_nmea_put_checksum(sentence, sizeof(sentence)); + loc_eng_nmea_send(sentence, length, loc_eng_data_p); + // ------------------ // ------$GPVTG------ // ------------------ @@ -565,6 +664,10 @@ void loc_eng_nmea_generate_pos(loc_eng_data_s_type *loc_eng_data_p, length = loc_eng_nmea_put_checksum(sentence, sizeof(sentence)); loc_eng_nmea_send(sentence, length, loc_eng_data_p); + strlcpy(sentence, "$GNGSA,A,1,,,,,,,,,,,,,,,", sizeof(sentence)); + length = loc_eng_nmea_put_checksum(sentence, sizeof(sentence)); + loc_eng_nmea_send(sentence, length, loc_eng_data_p); + strlcpy(sentence, "$GPVTG,,T,,M,,N,,K,N", sizeof(sentence)); length = loc_eng_nmea_put_checksum(sentence, sizeof(sentence)); loc_eng_nmea_send(sentence, length, loc_eng_data_p); @@ -604,7 +707,7 @@ SIDE EFFECTS ===========================================================================*/ void loc_eng_nmea_generate_sv(loc_eng_data_s_type *loc_eng_data_p, - const QcomSvStatus &svStatus, const GpsLocationExtended &locationExtended) + const GnssSvStatus &svStatus, const GpsLocationExtended &locationExtended) { ENTRY_LOG(); @@ -621,15 +724,27 @@ void loc_eng_nmea_generate_sv(loc_eng_data_s_type *loc_eng_data_p, //Count GPS SVs for saparating GPS from GLONASS and throw others + loc_eng_data_p->gps_used_mask = 0; + loc_eng_data_p->glo_used_mask = 0; for(svNumber=1; svNumber <= svCount; svNumber++) { - if( (svStatus.sv_list[svNumber-1].prn >= GPS_PRN_START)&& - (svStatus.sv_list[svNumber-1].prn <= GPS_PRN_END) ) + if (GNSS_CONSTELLATION_GPS == svStatus.gnss_sv_list[svNumber - 1].constellation) { + // cache the used in fix mask, as it will be needed to send $GPGSA + // during the position report + if (GNSS_SV_FLAGS_USED_IN_FIX == (svStatus.gnss_sv_list[svNumber - 1].flags & GNSS_SV_FLAGS_USED_IN_FIX)) + { + loc_eng_data_p->gps_used_mask |= (1 << (svStatus.gnss_sv_list[svNumber - 1].svid - 1)); + } gpsCount++; } - else if( (svStatus.sv_list[svNumber-1].prn >= GLONASS_PRN_START) && - (svStatus.sv_list[svNumber-1].prn <= GLONASS_PRN_END) ) + else if (GNSS_CONSTELLATION_GLONASS == svStatus.gnss_sv_list[svNumber - 1].constellation) { + // cache the used in fix mask, as it will be needed to send $GNGSA + // during the position report + if (GNSS_SV_FLAGS_USED_IN_FIX == (svStatus.gnss_sv_list[svNumber - 1].flags & GNSS_SV_FLAGS_USED_IN_FIX)) + { + loc_eng_data_p->glo_used_mask |= (1 << (svStatus.gnss_sv_list[svNumber - 1].svid - 1)); + } glnCount++; } } @@ -669,13 +784,12 @@ void loc_eng_nmea_generate_sv(loc_eng_data_s_type *loc_eng_data_p, for (int i=0; (svNumber <= svCount) && (i < 4); svNumber++) { - if( (svStatus.sv_list[svNumber-1].prn >= GPS_PRN_START) && - (svStatus.sv_list[svNumber-1].prn <= GPS_PRN_END) ) + if (GNSS_CONSTELLATION_GPS == svStatus.gnss_sv_list[svNumber - 1].constellation) { length = snprintf(pMarker, lengthRemaining,",%02d,%02d,%03d,", - svStatus.sv_list[svNumber-1].prn, - (int)(0.5 + svStatus.sv_list[svNumber-1].elevation), //float to int - (int)(0.5 + svStatus.sv_list[svNumber-1].azimuth)); //float to int + svStatus.gnss_sv_list[svNumber-1].svid, + (int)(0.5 + svStatus.gnss_sv_list[svNumber-1].elevation), //float to int + (int)(0.5 + svStatus.gnss_sv_list[svNumber-1].azimuth)); //float to int if (length < 0 || length >= lengthRemaining) { @@ -685,10 +799,10 @@ void loc_eng_nmea_generate_sv(loc_eng_data_s_type *loc_eng_data_p, pMarker += length; lengthRemaining -= length; - if (svStatus.sv_list[svNumber-1].snr > 0) + if (svStatus.gnss_sv_list[svNumber-1].c_n0_dbhz > 0) { length = snprintf(pMarker, lengthRemaining,"%02d", - (int)(0.5 + svStatus.sv_list[svNumber-1].snr)); //float to int + (int)(0.5 + svStatus.gnss_sv_list[svNumber-1].c_n0_dbhz)); //float to int if (length < 0 || length >= lengthRemaining) { @@ -747,13 +861,13 @@ void loc_eng_nmea_generate_sv(loc_eng_data_s_type *loc_eng_data_p, for (int i=0; (svNumber <= svCount) && (i < 4); svNumber++) { - if( (svStatus.sv_list[svNumber-1].prn >= GLONASS_PRN_START) && - (svStatus.sv_list[svNumber-1].prn <= GLONASS_PRN_END) ) { + if (GNSS_CONSTELLATION_GLONASS == svStatus.gnss_sv_list[svNumber - 1].constellation) + { length = snprintf(pMarker, lengthRemaining,",%02d,%02d,%03d,", - svStatus.sv_list[svNumber-1].prn, - (int)(0.5 + svStatus.sv_list[svNumber-1].elevation), //float to int - (int)(0.5 + svStatus.sv_list[svNumber-1].azimuth)); //float to int + svStatus.gnss_sv_list[svNumber - 1].svid, + (int)(0.5 + svStatus.gnss_sv_list[svNumber - 1].elevation), //float to int + (int)(0.5 + svStatus.gnss_sv_list[svNumber - 1].azimuth)); //float to int if (length < 0 || length >= lengthRemaining) { @@ -763,10 +877,10 @@ void loc_eng_nmea_generate_sv(loc_eng_data_s_type *loc_eng_data_p, pMarker += length; lengthRemaining -= length; - if (svStatus.sv_list[svNumber-1].snr > 0) + if (svStatus.gnss_sv_list[svNumber - 1].c_n0_dbhz > 0) { length = snprintf(pMarker, lengthRemaining,"%02d", - (int)(0.5 + svStatus.sv_list[svNumber-1].snr)); //float to int + (int)(0.5 + svStatus.gnss_sv_list[svNumber - 1].c_n0_dbhz)); //float to int if (length < 0 || length >= lengthRemaining) { @@ -790,10 +904,6 @@ void loc_eng_nmea_generate_sv(loc_eng_data_s_type *loc_eng_data_p, }//if - // cache the used in fix mask, as it will be needed to send $GPGSA - // during the position report - loc_eng_data_p->sv_used_mask = svStatus.gps_used_in_fix_mask; - // For RPC, the DOP are sent during sv report, so cache them // now to be sent during position report. // For QMI, the DOP will be in position report. diff --git a/gps/loc_api/libloc_api_50001/loc_eng_nmea.h b/gps/loc_api/libloc_api_50001/loc_eng_nmea.h index 2563a8f..066943a 100644 --- a/gps/loc_api/libloc_api_50001/loc_eng_nmea.h +++ b/gps/loc_api/libloc_api_50001/loc_eng_nmea.h @@ -37,7 +37,7 @@ void loc_eng_nmea_send(char *pNmea, int length, loc_eng_data_s_type *loc_eng_data_p); int loc_eng_nmea_put_checksum(char *pNmea, int maxSize); -void loc_eng_nmea_generate_sv(loc_eng_data_s_type *loc_eng_data_p, const QcomSvStatus &svStatus, const GpsLocationExtended &locationExtended); +void loc_eng_nmea_generate_sv(loc_eng_data_s_type *loc_eng_data_p, const GnssSvStatus &svStatus, const GpsLocationExtended &locationExtended); void loc_eng_nmea_generate_pos(loc_eng_data_s_type *loc_eng_data_p, const UlpLocation &location, const GpsLocationExtended &locationExtended, unsigned char generate_nmea); #endif // LOC_ENG_NMEA_H diff --git a/gps/loc_api/libloc_api_50001/loc_eng_xtra.cpp b/gps/loc_api/libloc_api_50001/loc_eng_xtra.cpp index 7bb8083..d334e0a 100644 --- a/gps/loc_api/libloc_api_50001/loc_eng_xtra.cpp +++ b/gps/loc_api/libloc_api_50001/loc_eng_xtra.cpp @@ -124,6 +124,13 @@ int loc_eng_xtra_init (loc_eng_data_s_type &loc_eng_data, loc_eng_xtra_data_s_type *xtra_module_data_ptr; ENTRY_LOG(); + if(!loc_eng_data.adapter->mSupportsTimeInjection + || loc_eng_data.adapter->hasNativeXtraClient()) { + LOC_LOGD("XTRA is already supported. disable it here.\n"); + EXIT_LOG(%d, 1); // return 1 denote failure + return 1; + } + if(callbacks == NULL) { LOC_LOGE("loc_eng_xtra_init: failed, cb is NULL"); } else { diff --git a/gps/utils/Android.mk b/gps/utils/Android.mk index 103e524..fae30cd 100644 --- a/gps/utils/Android.mk +++ b/gps/utils/Android.mk @@ -24,10 +24,10 @@ LOCAL_SRC_FILES += \ MsgTask.cpp \ loc_misc_utils.cpp +# Flag -std=c++11 is not accepted by compiler when LOCAL_CLANG is set to true LOCAL_CFLAGS += \ -fno-short-enums \ - -D_ANDROID_ \ - -std=c++11 + -D_ANDROID_ ifeq ($(TARGET_BUILD_VARIANT),user) LOCAL_CFLAGS += -DTARGET_BUILD_VARIANT_USER @@ -59,7 +59,6 @@ LOCAL_COPY_HEADERS:= \ loc_misc_utils.h LOCAL_MODULE := libgps.utils -LOCAL_CLANG := false LOCAL_MODULE_TAGS := optional diff --git a/gps/utils/LocThread.cpp b/gps/utils/LocThread.cpp index 19bf101..a7fd1c8 100644 --- a/gps/utils/LocThread.cpp +++ b/gps/utils/LocThread.cpp @@ -84,9 +84,7 @@ LocThreadDelegate::LocThreadDelegate(LocThread::tCreate creator, if (mThandle) { // set thread name char lname[16]; - int len = sizeof(lname) - 1; - memcpy(lname, threadName, len); - lname[len] = 0; + strlcpy(lname, threadName, sizeof(lname)); // set the thread name here pthread_setname_np(mThandle, lname); diff --git a/gps/utils/LocTimer.cpp b/gps/utils/LocTimer.cpp index 70904b2..4de6b40 100644 --- a/gps/utils/LocTimer.cpp +++ b/gps/utils/LocTimer.cpp @@ -505,8 +505,13 @@ int LocTimerDelegate::ranks(LocRankable& rankable) { LocTimerDelegate* timer = (LocTimerDelegate*)(&rankable); if (timer) { // larger time ranks lower!!! - // IOW, if input obj has bigger tv_sec, this obj outRanks higher + // IOW, if input obj has bigger tv_sec/tv_nsec, this obj outRanks higher rank = timer->mFutureTime.tv_sec - mFutureTime.tv_sec; + if(0 == rank) + { + //rank against tv_nsec for msec accuracy + rank = (int)(timer->mFutureTime.tv_nsec - mFutureTime.tv_nsec); + } } return rank; } diff --git a/gps/utils/log_util.h b/gps/utils/log_util.h index ffd5ca9..d27c800 100644 --- a/gps/utils/log_util.h +++ b/gps/utils/log_util.h @@ -159,6 +159,12 @@ else if (loc_logger.DEBUG_LEVEL == 0xff) { ALOGV("V/" __VA_ARGS__); } } \ } while(0) +#define LOC_LOG_HEAD(tag,fmt) "%s:%d][" tag "] " fmt "\n" +#define LOC_LOGv(tag,fmt,...) LOC_LOGV(LOC_LOG_HEAD(tag,fmt), __func__, __LINE__, ##__VA_ARGS__) +#define LOC_LOGw(tag,fmt,...) LOC_LOGW(LOC_LOG_HEAD(tag,fmt), __func__, __LINE__, ##__VA_ARGS__) +#define LOC_LOGd(tag,fmt,...) LOC_LOGD(LOC_LOG_HEAD(tag,fmt), __func__, __LINE__, ##__VA_ARGS__) +#define LOC_LOGe(tag,fmt,...) LOC_LOGE(LOC_LOG_HEAD(tag,fmt), __func__, __LINE__, ##__VA_ARGS__) + #define LOG_I(ID, WHAT, SPEC, VAL) LOG_(LOC_LOGI, ID, WHAT, SPEC, VAL) #define LOG_V(ID, WHAT, SPEC, VAL) LOG_(LOC_LOGV, ID, WHAT, SPEC, VAL) #define LOG_E(ID, WHAT, SPEC, VAL) LOG_(LOC_LOGE, ID, WHAT, SPEC, VAL)