From 5ae3b52b9ae5fbccd64b8208265cc5cb826f6843 Mon Sep 17 00:00:00 2001 From: Katz Yamada Date: Mon, 26 Mar 2018 20:46:47 -0700 Subject: [PATCH 01/14] Add location client api sockets' strings Add location client api socket path string definitions in utils/gps_extended_c.h. CRs-Fixed: 2196048 Change-Id: Ie2eea05dfe440fa3a96b531fa4ba17605ab53431 --- utils/gps_extended_c.h | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) diff --git a/utils/gps_extended_c.h b/utils/gps_extended_c.h index bd528d9e..f8cd21fc 100644 --- a/utils/gps_extended_c.h +++ b/utils/gps_extended_c.h @@ -1288,8 +1288,15 @@ typedef void (*LocAgpsOpenResultCb)(bool isSuccess, AGpsExtType agpsType, const typedef void (*LocAgpsCloseResultCb)(bool isSuccess, AGpsExtType agpsType, void* userDataPtr); /* Shared resources of LocIpc */ -#define LOC_IPC_HAL "/dev/socket/location/socket_hal" -#define LOC_IPC_XTRA "/dev/socket/location/xtra/socket_xtra" +#define LOC_IPC_HAL "/dev/socket/location/socket_hal" +#define LOC_IPC_XTRA "/dev/socket/location/xtra/socket_xtra" + +#define SOCKET_DIR_LOCATION "/dev/socket/location/" +#define SOCKET_DIR_EHUB "/dev/socket/location/ehub" +#define SOCKET_TO_LOCATION_HAL_DAEMON "/dev/socket/location/hal_daemon" + +#define SOCKET_DIR_TO_CLIENT "/dev/socket/loc_client/" +#define SOCKET_TO_LOCATION_CLIENT_BASE "/dev/socket/loc_client/toclient" #ifdef __cplusplus } From ae28b2989853a4de970ecaf78855d4bd0c34e362 Mon Sep 17 00:00:00 2001 From: Bhavna Sharma Date: Mon, 22 Jan 2018 16:04:50 -0800 Subject: [PATCH 02/14] Addition of new LocApi thread 1. LocApiBase to create its own MsgTask thread to allow QMI calls to be made asynchronously. It shall no longer share the adapter's thread. 2. Implementation of new LocApiResponse classes for generic response type from LocApi layer to Adapter layers. 3. GnssAdapter modified to handle the asynchronous nature of LocApi calls. CRs-Fixed: 2218658 Change-Id: I6e401a89f16791ec144763ac5f070b7ee1dad931 --- core/ContextBase.cpp | 41 +- core/ContextBase.h | 100 +++++ core/LBSProxyBase.h | 5 +- core/LocAdapterBase.cpp | 6 + core/LocAdapterBase.h | 4 +- core/LocApiBase.cpp | 187 ++++----- core/LocApiBase.h | 134 +++--- gnss/Agps.cpp | 8 +- gnss/Agps.h | 3 +- gnss/GnssAdapter.cpp | 884 +++++++++++++++++++++++----------------- gnss/GnssAdapter.h | 25 +- gnss/Makefile.am | 2 +- 12 files changed, 842 insertions(+), 557 deletions(-) diff --git a/core/ContextBase.cpp b/core/ContextBase.cpp index 47194cba..e7ee8bf1 100644 --- a/core/ContextBase.cpp +++ b/core/ContextBase.cpp @@ -42,6 +42,10 @@ namespace loc_core { loc_gps_cfg_s_type ContextBase::mGps_conf {}; loc_sap_cfg_s_type ContextBase::mSap_conf {}; +bool ContextBase::sIsEngineCapabilitiesKnown = false; +uint64_t ContextBase::sSupportedMsgMask = 0; +bool ContextBase::sGnssMeasurementSupported = false; +uint8_t ContextBase::sFeaturesSupported[MAX_FEATURE_LENGTH]; const loc_param_s_type ContextBase::mGps_conf_table[] = { @@ -215,7 +219,7 @@ LocApiBase* ContextBase::createLocApi(LOC_API_ADAPTER_EVENT_MASK_T exMask) // Check the target if (TARGET_NO_GNSS != loc_get_target()){ - if (NULL == (locApi = mLBSProxy->getLocApi(mMsgTask, exMask, this))) { + if (NULL == (locApi = mLBSProxy->getLocApi(exMask, this))) { void *handle = NULL; //try to see if LocApiV02 is present if ((handle = dlopen("libloc_api_v02.so", RTLD_NOW)) != NULL) { @@ -224,7 +228,7 @@ LocApiBase* ContextBase::createLocApi(LOC_API_ADAPTER_EVENT_MASK_T exMask) if (getter != NULL) { LOC_LOGD("%s:%d]: getter is not NULL for LocApiV02", __func__, __LINE__); - locApi = (*getter)(mMsgTask, exMask, this); + locApi = (*getter)(exMask, this); } } // only RPC is the option now @@ -237,7 +241,7 @@ LocApiBase* ContextBase::createLocApi(LOC_API_ADAPTER_EVENT_MASK_T exMask) if (NULL != getter) { LOC_LOGD("%s:%d]: getter is not NULL in RPC", __func__, __LINE__); - locApi = (*getter)(mMsgTask, exMask, this); + locApi = (*getter)(exMask, this); } } } @@ -247,7 +251,7 @@ LocApiBase* ContextBase::createLocApi(LOC_API_ADAPTER_EVENT_MASK_T exMask) // locApi could still be NULL at this time // we would then create a dummy one if (NULL == locApi) { - locApi = new LocApiBase(mMsgTask, exMask, this); + locApi = new LocApiBase(exMask, this); } return locApi; @@ -263,4 +267,33 @@ ContextBase::ContextBase(const MsgTask* msgTask, { } +void ContextBase::setEngineCapabilities(uint64_t supportedMsgMask, + uint8_t *featureList, bool gnssMeasurementSupported) { + + if (ContextBase::sIsEngineCapabilitiesKnown == false) { + ContextBase::sSupportedMsgMask = supportedMsgMask; + ContextBase::sGnssMeasurementSupported = gnssMeasurementSupported; + if (featureList != NULL) { + memcpy((void *)ContextBase::sFeaturesSupported, + (void *)featureList, sizeof(ContextBase::sFeaturesSupported)); + } + + ContextBase::sIsEngineCapabilitiesKnown = true; + } +} + + +bool ContextBase::isFeatureSupported(uint8_t featureVal) +{ + uint8_t arrayIndex = featureVal >> 3; + uint8_t bitPos = featureVal & 7; + + if (arrayIndex >= MAX_FEATURE_LENGTH) return false; + return ((ContextBase::sFeaturesSupported[arrayIndex] >> bitPos ) & 0x1); +} + +bool ContextBase::gnssConstellationConfig() { + return sGnssMeasurementSupported; +} + } diff --git a/core/ContextBase.h b/core/ContextBase.h index dc64b6ab..e7edb296 100644 --- a/core/ContextBase.h +++ b/core/ContextBase.h @@ -116,6 +116,7 @@ protected: const MsgTask* mMsgTask; LocApiBase* mLocApi; LocApiProxyBase *mLocApiProxy; + public: ContextBase(const MsgTask* msgTask, LOC_API_ADAPTER_EVENT_MASK_T exMask, @@ -140,12 +141,111 @@ public: static loc_gps_cfg_s_type mGps_conf; static loc_sap_cfg_s_type mSap_conf; + static bool sIsEngineCapabilitiesKnown; + static uint64_t sSupportedMsgMask; + static uint8_t sFeaturesSupported[MAX_FEATURE_LENGTH]; + static bool sGnssMeasurementSupported; void readConfig(); static uint32_t getCarrierCapabilities(); + void setEngineCapabilities(uint64_t supportedMsgMask, + uint8_t *featureList, bool gnssMeasurementSupported); + + static inline bool isEngineCapabilitiesKnown() { + return sIsEngineCapabilitiesKnown; + } + + static inline bool isMessageSupported(LocCheckingMessagesID msgID) { + + // confirm if msgID is not larger than the number of bits in + // mSupportedMsg + if ((uint64_t)msgID > (sizeof(sSupportedMsgMask) << 3)) { + return false; + } else { + uint32_t messageChecker = 1 << msgID; + return (messageChecker & sSupportedMsgMask) == messageChecker; + } + } + + /* + Check if a feature is supported + */ + static bool isFeatureSupported(uint8_t featureVal); + + /* + Check if gnss measurement is supported + */ + static bool gnssConstellationConfig(); }; +struct LocApiResponse: LocMsg { + private: + ContextBase& mContext; + std::function mProcImpl; + inline virtual void proc() const { + mProcImpl(mLocationError); + } + protected: + LocationError mLocationError; + public: + inline LocApiResponse(ContextBase& context, + std::function procImpl ) : + mContext(context), mProcImpl(procImpl) {} + + void returnToSender(const LocationError err) { + mLocationError = err; + mContext.sendMsg(this); + } +}; + +struct LocApiCollectiveResponse: LocMsg { + private: + ContextBase& mContext; + std::function errs)> mProcImpl; + inline virtual void proc() const { + mProcImpl(mLocationErrors); + } + protected: + std::vector mLocationErrors; + public: + inline LocApiCollectiveResponse(ContextBase& context, + std::function errs)> procImpl ) : + mContext(context), mProcImpl(procImpl) {} + inline virtual ~LocApiCollectiveResponse() { + } + + void returnToSender(std::vector& errs) { + mLocationErrors = errs; + mContext.sendMsg(this); + } +}; + + +template +struct LocApiResponseData: LocMsg { + private: + ContextBase& mContext; + std::function mProcImpl; + inline virtual void proc() const { + mProcImpl(mLocationError, mData); + } + protected: + LocationError mLocationError; + DATA mData; + public: + inline LocApiResponseData(ContextBase& context, + std::function procImpl ) : + mContext(context), mProcImpl(procImpl) {} + + void returnToSender(const LocationError err, const DATA data) { + mLocationError = err; + mData = data; + mContext.sendMsg(this); + } +}; + + } // namespace loc_core #endif //__LOC_CONTEXT_BASE__ diff --git a/core/LBSProxyBase.h b/core/LBSProxyBase.h index 94ddd0fb..bf786a35 100644 --- a/core/LBSProxyBase.h +++ b/core/LBSProxyBase.h @@ -29,7 +29,6 @@ #ifndef IZAT_PROXY_BASE_H #define IZAT_PROXY_BASE_H #include -#include namespace loc_core { @@ -40,11 +39,9 @@ class ContextBase; class LBSProxyBase { friend class ContextBase; inline virtual LocApiBase* - getLocApi(const MsgTask* msgTask, - LOC_API_ADAPTER_EVENT_MASK_T exMask, + getLocApi(LOC_API_ADAPTER_EVENT_MASK_T exMask, ContextBase* context) const { - (void)msgTask; (void)exMask; (void)context; return NULL; diff --git a/core/LocAdapterBase.cpp b/core/LocAdapterBase.cpp index f3c999c2..bf2be1c1 100644 --- a/core/LocAdapterBase.cpp +++ b/core/LocAdapterBase.cpp @@ -161,4 +161,10 @@ bool LocAdapterBase:: reportWwanZppFix(LocGpsLocation &/*zppLoc*/) DEFAULT_IMPL(false) +bool LocAdapterBase:: + reportZppBestAvailableFix(LocGpsLocation& /*zppLoc*/, + GpsLocationExtended& /*location_extended*/, LocPosTechMask /*tech_mask*/) +DEFAULT_IMPL(false) + + } // namespace loc_core diff --git a/core/LocAdapterBase.h b/core/LocAdapterBase.h index e7beca83..7fd4c5b5 100644 --- a/core/LocAdapterBase.h +++ b/core/LocAdapterBase.h @@ -107,7 +107,7 @@ public: } inline bool isFeatureSupported(uint8_t featureVal) { - return mLocApi->isFeatureSupported(featureVal); + return ContextBase::isFeatureSupported(featureVal); } uint32_t generateSessionId(); @@ -153,6 +153,8 @@ public: virtual void reportGnssMeasurementDataEvent(const GnssMeasurementsNotification& measurements, int msInWeek); virtual bool reportWwanZppFix(LocGpsLocation &zppLoc); + virtual bool reportZppBestAvailableFix(LocGpsLocation &zppLoc, + GpsLocationExtended &location_extended, LocPosTechMask tech_mask); }; } // namespace loc_core diff --git a/core/LocApiBase.cpp b/core/LocApiBase.cpp index 8aef94b3..8981e8b8 100644 --- a/core/LocApiBase.cpp +++ b/core/LocApiBase.cpp @@ -126,14 +126,36 @@ struct LocOpenMsg : public LocMsg { } }; -LocApiBase::LocApiBase(const MsgTask* msgTask, - LOC_API_ADAPTER_EVENT_MASK_T excludedMask, +struct LocCloseMsg : public LocMsg { + LocApiBase* mLocApi; + inline LocCloseMsg(LocApiBase* locApi) : + LocMsg(), mLocApi(locApi) + { + locallog(); + } + inline virtual void proc() const { + mLocApi->close(); + } + inline void locallog() const { + LOC_LOGV("%s]: LocCloseMsg"); + } + inline virtual void log() const { + locallog(); + } +}; + +MsgTask* LocApiBase::mMsgTask; + +LocApiBase::LocApiBase(LOC_API_ADAPTER_EVENT_MASK_T excludedMask, ContextBase* context) : - mMsgTask(msgTask), mContext(context), mSupportedMsg(0), + mContext(context), mMask(0), mExcludedMask(excludedMask) { memset(mLocAdapters, 0, sizeof(mLocAdapters)); - memset(mFeaturesSupported, 0, sizeof(mFeaturesSupported)); + + if (nullptr == mMsgTask) { + mMsgTask = new MsgTask("LocApiMsgTask", false); + } } LOC_API_ADAPTER_EVENT_MASK_T LocApiBase::getEvtMask() @@ -197,7 +219,7 @@ void LocApiBase::removeAdapter(LocAdapterBase* adapter) // if we have an empty list of adapters if (0 == i) { - close(); + mMsgTask->sendMsg(new LocCloseMsg(this)); } else { // else we need to remove the bit mMsgTask->sendMsg(new LocOpenMsg(this, getEvtMask())); @@ -208,14 +230,11 @@ void LocApiBase::removeAdapter(LocAdapterBase* adapter) void LocApiBase::updateEvtMask() { - open(getEvtMask()); + mMsgTask->sendMsg(new LocOpenMsg(this, getEvtMask())); } void LocApiBase::handleEngineUpEvent() { - // This will take care of renegotiating the loc handle - mMsgTask->sendMsg(new LocSsrMsg(this)); - LocDualContext::injectFeatureConfig(mContext); // loop through adapters, and deliver to all adapters. @@ -223,7 +242,9 @@ void LocApiBase::handleEngineUpEvent() } void LocApiBase::handleEngineDownEvent() -{ +{ // This will take care of renegotiating the loc handle + sendMsg(new LocSsrMsg(this)); + // loop through adapters, and deliver to all adapters. TO_ALL_LOCADAPTERS(mLocAdapters[i]->handleEngineDownEvent()); } @@ -239,7 +260,7 @@ void LocApiBase::reportPosition(UlpLocation& location, "timestamp: %" PRId64 "\n" "Session status: %d\n Technology mask: %u\n " "SV used in fix (gps/glo/bds/gal/qzss) : \ - (%" PRIx64 "/%" PRIx64 "/%" PRIx64 "/%" PRIx64 "/%" PRIx64 ")", + (0x%" PRIx64 "/0x%" PRIx64 "/0x%" PRIx64 "/0x%" PRIx64 "/0x%" PRIx64 ")", location.gpsLocation.flags, location.position_source, location.gpsLocation.latitude, location.gpsLocation.longitude, location.gpsLocation.altitude, location.gpsLocation.speed, @@ -263,6 +284,15 @@ void LocApiBase::reportWwanZppFix(LocGpsLocation &zppLoc) TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->reportWwanZppFix(zppLoc)); } +void LocApiBase::reportZppBestAvailableFix(LocGpsLocation &zppLoc, + GpsLocationExtended &location_extended, LocPosTechMask tech_mask) +{ + // loop through adapters, and deliver to the first handling adapter. + TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->reportZppBestAvailableFix(zppLoc, + location_extended, tech_mask)); +} + + void LocApiBase::reportSv(GnssSvNotification& svNotify) { const char* constellationString[] = { "Unknown", "GPS", "SBAS", "GLONASS", @@ -384,16 +414,6 @@ void LocApiBase::requestNiNotify(GnssNiNotification ¬ify, const void* data) TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->requestNiNotifyEvent(notify, data)); } -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) @@ -415,86 +435,72 @@ enum loc_api_adapter_err LocApiBase:: close() DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) -enum loc_api_adapter_err LocApiBase:: - startFix(const LocPosMode& /*posMode*/) -DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) +void LocApiBase::startFix(const LocPosMode& /*posMode*/, LocApiResponse* /*adapterResponse*/) +DEFAULT_IMPL() -enum loc_api_adapter_err LocApiBase:: - stopFix() -DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) +void LocApiBase::stopFix(LocApiResponse* /*adapterResponse*/) +DEFAULT_IMPL() -LocationError LocApiBase:: - deleteAidingData(const GnssAidingData& /*data*/) -DEFAULT_IMPL(LOCATION_ERROR_SUCCESS) +void LocApiBase:: + deleteAidingData(const GnssAidingData& /*data*/, LocApiResponse* /*adapterResponse*/) +DEFAULT_IMPL() -enum loc_api_adapter_err LocApiBase:: - enableData(int /*enable*/) -DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) - -enum loc_api_adapter_err LocApiBase:: - setAPN(char* /*apn*/, int /*len*/) -DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) - -enum loc_api_adapter_err LocApiBase:: +void LocApiBase:: injectPosition(double /*latitude*/, double /*longitude*/, float /*accuracy*/) -DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) +DEFAULT_IMPL() -enum loc_api_adapter_err LocApiBase:: +void LocApiBase:: setTime(LocGpsUtcTime /*time*/, int64_t /*timeReference*/, int /*uncertainty*/) -DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) +DEFAULT_IMPL() enum loc_api_adapter_err LocApiBase:: setXtraData(char* /*data*/, int /*length*/) DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) -enum loc_api_adapter_err LocApiBase:: - requestXtraServer() -DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) - -enum loc_api_adapter_err LocApiBase:: - atlOpenStatus(int /*handle*/, int /*is_succ*/, char* /*apn*/, +void LocApiBase:: + atlOpenStatus(int /*handle*/, int /*is_succ*/, char* /*apn*/, uint32_t /*apnLen*/, AGpsBearerType /*bear*/, LocAGpsType /*agpsType*/) -DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) +DEFAULT_IMPL() -enum loc_api_adapter_err LocApiBase:: +void LocApiBase:: atlCloseStatus(int /*handle*/, int /*is_succ*/) -DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) +DEFAULT_IMPL() -enum loc_api_adapter_err LocApiBase:: +void LocApiBase:: setPositionMode(const LocPosMode& /*posMode*/) -DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) +DEFAULT_IMPL() LocationError LocApiBase:: - setServer(const char* /*url*/, int /*len*/) + setServerSync(const char* /*url*/, int /*len*/) DEFAULT_IMPL(LOCATION_ERROR_SUCCESS) LocationError LocApiBase:: - setServer(unsigned int /*ip*/, int /*port*/, LocServerType /*type*/) + setServerSync(unsigned int /*ip*/, int /*port*/, LocServerType /*type*/) DEFAULT_IMPL(LOCATION_ERROR_SUCCESS) -LocationError LocApiBase:: +void LocApiBase:: informNiResponse(GnssNiResponse /*userResponse*/, const void* /*passThroughData*/) -DEFAULT_IMPL(LOCATION_ERROR_SUCCESS) +DEFAULT_IMPL() LocationError LocApiBase:: - setSUPLVersion(GnssConfigSuplVersion /*version*/) + setSUPLVersionSync(GnssConfigSuplVersion /*version*/) DEFAULT_IMPL(LOCATION_ERROR_SUCCESS) enum loc_api_adapter_err LocApiBase:: - setNMEATypes (uint32_t /*typesMask*/) + setNMEATypesSync (uint32_t /*typesMask*/) DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) LocationError LocApiBase:: - setLPPConfig(GnssConfigLppProfile /*profile*/) + setLPPConfigSync(GnssConfigLppProfile /*profile*/) DEFAULT_IMPL(LOCATION_ERROR_SUCCESS) enum loc_api_adapter_err LocApiBase:: - setSensorControlConfig(int /*sensorUsage*/, + setSensorControlConfigSync(int /*sensorUsage*/, int /*sensorProvider*/) DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) enum loc_api_adapter_err LocApiBase:: - setSensorProperties(bool /*gyroBiasVarianceRandomWalk_valid*/, + setSensorPropertiesSync(bool /*gyroBiasVarianceRandomWalk_valid*/, float /*gyroBiasVarianceRandomWalk*/, bool /*accelBiasVarianceRandomWalk_valid*/, float /*accelBiasVarianceRandomWalk*/, @@ -507,7 +513,7 @@ enum loc_api_adapter_err LocApiBase:: DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) enum loc_api_adapter_err LocApiBase:: - setSensorPerfControlConfig(int /*controlMode*/, + setSensorPerfControlConfigSync(int /*controlMode*/, int /*accelSamplesPerBatch*/, int /*accelBatchesPerSec*/, int /*gyroSamplesPerBatch*/, @@ -520,37 +526,36 @@ enum loc_api_adapter_err LocApiBase:: DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) LocationError LocApiBase:: - setAGLONASSProtocol(GnssConfigAGlonassPositionProtocolMask /*aGlonassProtocol*/) + setAGLONASSProtocolSync(GnssConfigAGlonassPositionProtocolMask /*aGlonassProtocol*/) DEFAULT_IMPL(LOCATION_ERROR_SUCCESS) LocationError LocApiBase:: - setLPPeProtocolCp(GnssConfigLppeControlPlaneMask /*lppeCP*/) + setLPPeProtocolCpSync(GnssConfigLppeControlPlaneMask /*lppeCP*/) DEFAULT_IMPL(LOCATION_ERROR_SUCCESS) LocationError LocApiBase:: - setLPPeProtocolUp(GnssConfigLppeUserPlaneMask /*lppeUP*/) + setLPPeProtocolUpSync(GnssConfigLppeUserPlaneMask /*lppeUP*/) DEFAULT_IMPL(LOCATION_ERROR_SUCCESS) +GnssConfigSuplVersion LocApiBase::convertSuplVersion(const uint32_t /*suplVersion*/) +DEFAULT_IMPL(GNSS_CONFIG_SUPL_VERSION_1_0_0) + +GnssConfigLppProfile LocApiBase::convertLppProfile(const uint32_t /*lppProfile*/) +DEFAULT_IMPL(GNSS_CONFIG_LPP_PROFILE_RRLP_ON_LTE) + +GnssConfigLppeControlPlaneMask LocApiBase::convertLppeCp(const uint32_t /*lppeControlPlaneMask*/) +DEFAULT_IMPL(0) + +GnssConfigLppeUserPlaneMask LocApiBase::convertLppeUp(const uint32_t /*lppeUserPlaneMask*/) +DEFAULT_IMPL(0) + enum loc_api_adapter_err LocApiBase:: getWwanZppFix() DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) -enum loc_api_adapter_err LocApiBase:: - getBestAvailableZppFix(LocGpsLocation& zppLoc) -{ - memset(&zppLoc, 0, sizeof(zppLoc)); - DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) -} - -enum loc_api_adapter_err LocApiBase:: - getBestAvailableZppFix(LocGpsLocation & zppLoc, GpsLocationExtended & locationExtended, - LocPosTechMask & tech_mask) -{ - memset(&zppLoc, 0, sizeof(zppLoc)); - memset(&tech_mask, 0, sizeof(tech_mask)); - memset(&locationExtended, 0, sizeof (locationExtended)); - DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) -} +void LocApiBase:: + getBestAvailableZppFix() +DEFAULT_IMPL() int LocApiBase:: initDataServiceClient(bool /*isDueToSsr*/) @@ -573,7 +578,7 @@ void LocApiBase:: DEFAULT_IMPL() LocationError LocApiBase:: - setGpsLock(GnssConfigGpsLock /*lock*/) + setGpsLockSync(GnssConfigGpsLock /*lock*/) DEFAULT_IMPL(LOCATION_ERROR_SUCCESS) void LocApiBase:: @@ -587,21 +592,7 @@ int LocApiBase:: DEFAULT_IMPL(-1) LocationError LocApiBase:: - setXtraVersionCheck(uint32_t /*check*/) + setXtraVersionCheckSync(uint32_t /*check*/) DEFAULT_IMPL(LOCATION_ERROR_SUCCESS) -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/core/LocApiBase.h b/core/LocApiBase.h index 25d95b2a..f0b1f592 100644 --- a/core/LocApiBase.h +++ b/core/LocApiBase.h @@ -37,7 +37,9 @@ #include namespace loc_core { + class ContextBase; +struct LocApiResponse; int hexcode(char *hexstring, int string_size, const char *data, int data_size); @@ -66,6 +68,28 @@ class LocAdapterBase; struct LocSsrMsg; struct LocOpenMsg; +typedef struct +{ + uint32_t accumulatedDistance; + uint32_t numOfBatchedPositions; +} LocApiBatchData; + +typedef struct +{ + uint32_t hwId; +} LocApiGeofenceData; + +struct LocApiMsg: LocMsg { + private: + std::function mProcImpl; + inline virtual void proc() const { + mProcImpl(); + } + public: + inline LocApiMsg(std::function procImpl ) : + mProcImpl(procImpl) {} +}; + class LocApiProxyBase { public: inline LocApiProxyBase() {} @@ -78,22 +102,21 @@ class LocApiBase { //LocOpenMsg calls open() which makes it necessary to declare //it as a friend friend struct LocOpenMsg; + friend struct LocCloseMsg; friend class ContextBase; - const MsgTask* mMsgTask; - ContextBase *mContext; + static MsgTask* mMsgTask; LocAdapterBase* mLocAdapters[MAX_ADAPTERS]; - uint64_t mSupportedMsg; - uint8_t mFeaturesSupported[MAX_FEATURE_LENGTH]; + protected: + ContextBase *mContext; virtual enum loc_api_adapter_err open(LOC_API_ADAPTER_EVENT_MASK_T mask); virtual enum loc_api_adapter_err close(); LOC_API_ADAPTER_EVENT_MASK_T getEvtMask(); LOC_API_ADAPTER_EVENT_MASK_T mMask; - LocApiBase(const MsgTask* msgTask, - LOC_API_ADAPTER_EVENT_MASK_T excludedMask, + LocApiBase(LOC_API_ADAPTER_EVENT_MASK_T excludedMask, ContextBase* context = NULL); inline virtual ~LocApiBase() { close(); } bool isInSession(); @@ -130,10 +153,10 @@ public: void reportDataCallOpened(); void reportDataCallClosed(); void requestNiNotify(GnssNiNotification ¬ify, const void* data); - void saveSupportedMsgList(uint64_t supportedMsgList); void reportGnssMeasurementData(GnssMeasurementsNotification& measurements, int msInWeek); - void saveSupportedFeatureList(uint8_t *featureList); void reportWwanZppFix(LocGpsLocation &zppLoc); + void reportZppBestAvailableFix(LocGpsLocation &zppLoc, GpsLocationExtended &location_extended, + LocPosTechMask tech_mask); // downward calls // All below functions are to be defined by adapter specific modules: @@ -141,45 +164,43 @@ public: virtual void* getSibling(); virtual LocApiProxyBase* getLocApiProxy(); - virtual enum loc_api_adapter_err - startFix(const LocPosMode& posMode); - virtual enum loc_api_adapter_err - stopFix(); - virtual LocationError - deleteAidingData(const GnssAidingData& data); - virtual enum loc_api_adapter_err - enableData(int enable); - virtual enum loc_api_adapter_err - setAPN(char* apn, int len); - virtual enum loc_api_adapter_err + virtual void startFix(const LocPosMode& fixCriteria, LocApiResponse* adapterResponse); + virtual void + stopFix(LocApiResponse* adapterResponse); + virtual void + deleteAidingData(const GnssAidingData& data, LocApiResponse* adapterResponse); + + virtual void injectPosition(double latitude, double longitude, float accuracy); - virtual enum loc_api_adapter_err + virtual void setTime(LocGpsUtcTime time, int64_t timeReference, int uncertainty); + + // // TODO:: called from izatapipds virtual enum loc_api_adapter_err setXtraData(char* data, int length); - virtual enum loc_api_adapter_err - requestXtraServer(); - virtual enum loc_api_adapter_err - atlOpenStatus(int handle, int is_succ, char* apn, AGpsBearerType bear, LocAGpsType agpsType); - virtual enum loc_api_adapter_err + + virtual void + atlOpenStatus(int handle, int is_succ, char* apn, uint32_t apnLen, + AGpsBearerType bear, LocAGpsType agpsType); + virtual void atlCloseStatus(int handle, int is_succ); - virtual enum loc_api_adapter_err + virtual void setPositionMode(const LocPosMode& posMode); virtual LocationError - setServer(const char* url, int len); + setServerSync(const char* url, int len); virtual LocationError - setServer(unsigned int ip, int port, + setServerSync(unsigned int ip, int port, LocServerType type); - virtual LocationError + virtual void informNiResponse(GnssNiResponse userResponse, const void* passThroughData); - virtual LocationError setSUPLVersion(GnssConfigSuplVersion version); + virtual LocationError setSUPLVersionSync(GnssConfigSuplVersion version); virtual enum loc_api_adapter_err - setNMEATypes (uint32_t typesMask); - virtual LocationError setLPPConfig(GnssConfigLppProfile profile); + setNMEATypesSync(uint32_t typesMask); + virtual LocationError setLPPConfigSync(GnssConfigLppProfile profile); virtual enum loc_api_adapter_err - setSensorControlConfig(int sensorUsage, int sensorProvider); + setSensorControlConfigSync(int sensorUsage, int sensorProvider); virtual enum loc_api_adapter_err - setSensorProperties(bool gyroBiasVarianceRandomWalk_valid, + setSensorPropertiesSync(bool gyroBiasVarianceRandomWalk_valid, float gyroBiasVarianceRandomWalk, bool accelBiasVarianceRandomWalk_valid, float accelBiasVarianceRandomWalk, @@ -190,7 +211,7 @@ public: bool velocityBiasVarianceRandomWalk_valid, float velocityBiasVarianceRandomWalk); virtual enum loc_api_adapter_err - setSensorPerfControlConfig(int controlMode, + setSensorPerfControlConfigSync(int controlMode, int accelSamplesPerBatch, int accelBatchesPerSec, int gyroSamplesPerBatch, @@ -201,16 +222,18 @@ public: int gyroBatchesPerSecHigh, int algorithmConfig); virtual LocationError - setAGLONASSProtocol(GnssConfigAGlonassPositionProtocolMask aGlonassProtocol); - virtual LocationError setLPPeProtocolCp(GnssConfigLppeControlPlaneMask lppeCP); - virtual LocationError setLPPeProtocolUp(GnssConfigLppeUserPlaneMask lppeUP); + setAGLONASSProtocolSync(GnssConfigAGlonassPositionProtocolMask aGlonassProtocol); + virtual LocationError setLPPeProtocolCpSync(GnssConfigLppeControlPlaneMask lppeCP); + virtual LocationError setLPPeProtocolUpSync(GnssConfigLppeUserPlaneMask lppeUP); + virtual GnssConfigSuplVersion convertSuplVersion(const uint32_t suplVersion); + virtual GnssConfigLppProfile convertLppProfile(const uint32_t lppProfile); + virtual GnssConfigLppeControlPlaneMask convertLppeCp(const uint32_t lppeControlPlaneMask); + virtual GnssConfigLppeUserPlaneMask convertLppeUp(const uint32_t lppeUserPlaneMask); + virtual enum loc_api_adapter_err getWwanZppFix(); - virtual enum loc_api_adapter_err - getBestAvailableZppFix(LocGpsLocation & zppLoc); - virtual enum loc_api_adapter_err - getBestAvailableZppFix(LocGpsLocation & zppLoc, GpsLocationExtended & locationExtended, - LocPosTechMask & tech_mask); + virtual void + getBestAvailableZppFix(); virtual int initDataServiceClient(bool isDueToSsr); virtual int openAndStartDataCall(); virtual void stopDataCall(); @@ -223,21 +246,11 @@ public: (void)inSession; } - inline bool isMessageSupported (LocCheckingMessagesID msgID) const { - // 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; - return (messageChecker & mSupportedMsg) == messageChecker; - } - } void updateEvtMask(); - virtual LocationError setGpsLock(GnssConfigGpsLock lock); + virtual LocationError setGpsLockSync(GnssConfigGpsLock lock); /* Returns Current value of GPS Lock on success @@ -245,20 +258,11 @@ public: */ virtual int getGpsLock(void); - virtual LocationError setXtraVersionCheck(uint32_t check); - /* - Check if the modem support the service - */ - virtual bool gnssConstellationConfig(); + virtual LocationError setXtraVersionCheckSync(uint32_t check); - /* - Check if a feature is supported - */ - bool isFeatureSupported(uint8_t featureVal); }; -typedef LocApiBase* (getLocApi_t)(const MsgTask* msgTask, - LOC_API_ADAPTER_EVENT_MASK_T exMask, +typedef LocApiBase* (getLocApi_t)(LOC_API_ADAPTER_EVENT_MASK_T exMask, ContextBase *context); } // namespace loc_core diff --git a/gnss/Agps.cpp b/gnss/Agps.cpp index 6ce0c345..d6a75aba 100644 --- a/gnss/Agps.cpp +++ b/gnss/Agps.cpp @@ -360,13 +360,13 @@ void AgpsStateMachine::notifyEventToSubscriber( case AGPS_EVENT_GRANTED: mAgpsManager->mAtlOpenStatusCb( - subscriberToNotify->mConnHandle, 1, getAPN(), + subscriberToNotify->mConnHandle, 1, getAPN(), getAPNLen(), getBearer(), mAgpsType); break; case AGPS_EVENT_DENIED: mAgpsManager->mAtlOpenStatusCb( - subscriberToNotify->mConnHandle, 0, getAPN(), + subscriberToNotify->mConnHandle, 0, getAPN(), getAPNLen(), getBearer(), mAgpsType); break; @@ -661,7 +661,7 @@ void DSStateMachine::notifyEventToSubscriber( case AGPS_EVENT_GRANTED: mAgpsManager->mAtlOpenStatusCb( - subscriberToNotify->mConnHandle, 1, NULL, + subscriberToNotify->mConnHandle, 1, NULL, 0, AGPS_APN_BEARER_INVALID, LOC_AGPS_TYPE_SUPL_ES); break; @@ -778,7 +778,7 @@ void AgpsManager::requestATL(int connHandle, AGpsExtType agpsType){ LOC_LOGE("No AGPS State Machine for agpsType: %d", agpsType); mAtlOpenStatusCb( - connHandle, 0, NULL, AGPS_APN_BEARER_INVALID, agpsType); + connHandle, 0, NULL, 0, AGPS_APN_BEARER_INVALID, agpsType); return; } diff --git a/gnss/Agps.h b/gnss/Agps.h index 703a4750..f9a54f84 100644 --- a/gnss/Agps.h +++ b/gnss/Agps.h @@ -40,7 +40,7 @@ /* ATL callback function pointers * Passed in by Adapter to AgpsManager */ typedef std::function AgpsAtlOpenStatusCb; typedef std::function AgpsAtlCloseStatusCb; @@ -169,6 +169,7 @@ public: /* Getter/Setter methods */ void setAPN(char* apn, unsigned int len); inline char* getAPN() const { return (char*)mAPN; } + inline uint32_t getAPNLen() const { return mAPNLen; } inline void setBearer(AGpsBearerType bearer) { mBearer = bearer; } inline AGpsBearerType getBearer() const { return mBearer; } inline AGpsExtType getType() const { return mAgpsType; } diff --git a/gnss/GnssAdapter.cpp b/gnss/GnssAdapter.cpp index f996ebee..91c88d6b 100644 --- a/gnss/GnssAdapter.cpp +++ b/gnss/GnssAdapter.cpp @@ -92,11 +92,11 @@ GnssAdapter::GnssAdapter() : /* Set ATL open/close callbacks */ AgpsAtlOpenStatusCb atlOpenStatusCb = - [this](int handle, int isSuccess, char* apn, + [this](int handle, int isSuccess, char* apn, uint32_t apnLen, AGpsBearerType bearerType, AGpsExtType agpsType) { mLocApi->atlOpenStatus( - handle, isSuccess, apn, bearerType, agpsType); + handle, isSuccess, apn, apnLen, bearerType, agpsType); }; AgpsAtlCloseStatusCb atlCloseStatusCb = [this](int handle, int isSuccess) { @@ -146,7 +146,7 @@ GnssAdapter::GnssAdapter() : dsClientCloseDataCallFn, dsClientReleaseFn, sendMsgFn); readConfigCommand(); - setConfigCommand(); + requestUlpCommand(); initDefaultAgpsCommand(); initEngHubProxyCommand(); } @@ -415,20 +415,6 @@ GnssAdapter::convertSuplVersion(const GnssConfigSuplVersion suplVersion) } } -inline GnssConfigSuplVersion -GnssAdapter::convertSuplVersion(const uint32_t suplVersion) -{ - switch (suplVersion) { - case 0x00020000: - return GNSS_CONFIG_SUPL_VERSION_2_0_0; - case 0x00020002: - return GNSS_CONFIG_SUPL_VERSION_2_0_2; - case 0x00010000: - default: - return GNSS_CONFIG_SUPL_VERSION_1_0_0; - } -} - inline uint32_t GnssAdapter::convertLppProfile(const GnssConfigLppProfile lppProfile) { @@ -445,22 +431,6 @@ GnssAdapter::convertLppProfile(const GnssConfigLppProfile lppProfile) } } -inline GnssConfigLppProfile -GnssAdapter::convertLppProfile(const uint32_t lppProfile) -{ - switch (lppProfile) { - case 1: - return GNSS_CONFIG_LPP_PROFILE_USER_PLANE; - case 2: - return GNSS_CONFIG_LPP_PROFILE_CONTROL_PLANE; - case 3: - return GNSS_CONFIG_LPP_PROFILE_USER_PLANE_AND_CONTROL_PLANE; - case 0: - default: - return GNSS_CONFIG_LPP_PROFILE_RRLP_ON_LTE; - } -} - uint32_t GnssAdapter::convertLppeCp(const GnssConfigLppeControlPlaneMask lppeControlPlaneMask) { @@ -480,26 +450,6 @@ GnssAdapter::convertLppeCp(const GnssConfigLppeControlPlaneMask lppeControlPlane return mask; } -GnssConfigLppeControlPlaneMask -GnssAdapter::convertLppeCp(const uint32_t lppeControlPlaneMask) -{ - GnssConfigLppeControlPlaneMask mask = 0; - if ((1<<0) & lppeControlPlaneMask) { - mask |= GNSS_CONFIG_LPPE_CONTROL_PLANE_DBH_BIT; - } - if ((1<<1) & lppeControlPlaneMask) { - mask |= GNSS_CONFIG_LPPE_CONTROL_PLANE_WLAN_AP_MEASUREMENTS_BIT; - } - if ((1<<2) & lppeControlPlaneMask) { - mask |= GNSS_CONFIG_LPPE_CONTROL_PLANE_SRN_AP_MEASUREMENTS_BIT; - } - if ((1<<3) & lppeControlPlaneMask) { - mask |= GNSS_CONFIG_LPPE_CONTROL_PLANE_SENSOR_BARO_MEASUREMENTS_BIT; - } - return mask; -} - - uint32_t GnssAdapter::convertLppeUp(const GnssConfigLppeUserPlaneMask lppeUserPlaneMask) { @@ -519,25 +469,6 @@ GnssAdapter::convertLppeUp(const GnssConfigLppeUserPlaneMask lppeUserPlaneMask) return mask; } -GnssConfigLppeUserPlaneMask -GnssAdapter::convertLppeUp(const uint32_t lppeUserPlaneMask) -{ - GnssConfigLppeUserPlaneMask mask = 0; - if ((1<<0) & lppeUserPlaneMask) { - mask |= GNSS_CONFIG_LPPE_USER_PLANE_DBH_BIT; - } - if ((1<<1) & lppeUserPlaneMask) { - mask |= GNSS_CONFIG_LPPE_USER_PLANE_WLAN_AP_MEASUREMENTS_BIT; - } - if ((1<<2) & lppeUserPlaneMask) { - mask |= GNSS_CONFIG_LPPE_USER_PLANE_SRN_AP_MEASUREMENTS_BIT; - } - if ((1<<3) & lppeUserPlaneMask) { - mask |= GNSS_CONFIG_LPPE_USER_PLANE_SENSOR_BARO_MEASUREMENTS_BIT; - } - return mask; -} - uint32_t GnssAdapter::convertAGloProt(const GnssConfigAGlonassPositionProtocolMask aGloPositionProtocolMask) { @@ -594,27 +525,6 @@ GnssAdapter::convertSuplMode(const GnssConfigSuplModeMask suplModeMask) return mask; } -bool -GnssAdapter::resolveInAddress(const char* hostAddress, struct in_addr* inAddress) -{ - bool ret = true; - - struct hostent* hp; - hp = gethostbyname(hostAddress); - if (hp != NULL) { /* DNS OK */ - memcpy(inAddress, hp->h_addr_list[0], hp->h_length); - } else { - /* Try IP representation */ - if (inet_aton(hostAddress, inAddress) == 0) { - /* IP not valid */ - LOC_LOGE("%s]: DNS query on '%s' failed", __func__, hostAddress); - ret = false; - } - } - - return ret; -} - void GnssAdapter::readConfigCommand() { @@ -640,17 +550,37 @@ GnssAdapter::readConfigCommand() } } -LocationError +void +GnssAdapter::requestUlpCommand() +{ + LOC_LOGD("%s]: ", __func__); + + struct MsgRequestUlp : public LocMsg { + GnssAdapter* mAdapter; + ContextBase& mContext; + inline MsgRequestUlp(GnssAdapter* adapter, + ContextBase& context) : + LocMsg(), + mAdapter(adapter), + mContext(context) {} + inline virtual void proc() const { + mContext.requestUlp((LocAdapterBase*)mAdapter, mContext.getCarrierCapabilities()); + } + }; + + if (mContext != NULL) { + sendMsg(new MsgRequestUlp(this, *mContext)); + } +} + +void GnssAdapter::setSuplHostServer(const char* server, int port) { - LocationError locErr = LOCATION_ERROR_SUCCESS; if (ContextBase::mGps_conf.AGPS_CONFIG_INJECT) { char serverUrl[MAX_URL_LEN] = {}; int32_t length = -1; const char noHost[] = "NONE"; - locErr = LOCATION_ERROR_INVALID_PARAMETER; - if ((NULL == server) || (server[0] == 0) || (strncasecmp(noHost, server, sizeof(noHost)) == 0)) { serverUrl[0] = NULL; @@ -662,14 +592,8 @@ GnssAdapter::setSuplHostServer(const char* server, int port) if (length >= 0 && strncasecmp(getServerUrl().c_str(), serverUrl, sizeof(serverUrl)) != 0) { setServerUrl(serverUrl); - locErr = mLocApi->setServer(serverUrl, length); - if (locErr != LOCATION_ERROR_SUCCESS) { - LOC_LOGE("%s]:Error while setting SUPL_HOST server:%s", - __func__, serverUrl); - } } } - return locErr; } void @@ -680,68 +604,105 @@ GnssAdapter::setConfigCommand() struct MsgSetConfig : public LocMsg { GnssAdapter& mAdapter; LocApiBase& mApi; - inline MsgSetConfig(GnssAdapter& adapter, - LocApiBase& api) : + inline MsgSetConfig(GnssAdapter& adapter, LocApiBase& api) : LocMsg(), mAdapter(adapter), mApi(api) {} inline virtual void proc() const { - if (ContextBase::mGps_conf.AGPS_CONFIG_INJECT) { - mApi.setSUPLVersion(mAdapter.convertSuplVersion(ContextBase::mGps_conf.SUPL_VER)); - mApi.setLPPConfig(mAdapter.convertLppProfile(ContextBase::mGps_conf.LPP_PROFILE)); - mApi.setAGLONASSProtocol(ContextBase::mGps_conf.A_GLONASS_POS_PROTOCOL_SELECT); - } - mAdapter.setSuplHostServer(ContextBase::mGps_conf.SUPL_HOST, - ContextBase::mGps_conf.SUPL_PORT); - mApi.setSensorControlConfig(ContextBase::mSap_conf.SENSOR_USAGE, - ContextBase::mSap_conf.SENSOR_PROVIDER); - mApi.setLPPeProtocolCp( - mAdapter.convertLppeCp(ContextBase::mGps_conf.LPPE_CP_TECHNOLOGY)); - mApi.setLPPeProtocolUp( - mAdapter.convertLppeUp(ContextBase::mGps_conf.LPPE_UP_TECHNOLOGY)); // set nmea mask type uint32_t mask = 0; if (NMEA_PROVIDER_MP == ContextBase::mGps_conf.NMEA_PROVIDER) { mask |= LOC_NMEA_ALL_GENERAL_SUPPORTED_MASK; } - if (mApi.isFeatureSupported(LOC_SUPPORTED_FEATURE_DEBUG_NMEA_V02)) { + if (ContextBase::isFeatureSupported(LOC_SUPPORTED_FEATURE_DEBUG_NMEA_V02)) { mask |= LOC_NMEA_MASK_DEBUG_V02; } - if (mask != 0) { - mApi.setNMEATypes(mask); - } mAdapter.mNmeaMask= mask; - mApi.setXtraVersionCheck(ContextBase::mGps_conf.XTRA_VERSION_CHECK); - if (ContextBase::mSap_conf.GYRO_BIAS_RANDOM_WALK_VALID || - ContextBase::mSap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY_VALID || - ContextBase::mSap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY_VALID || - ContextBase::mSap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY_VALID || - ContextBase::mSap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY_VALID ) { - mApi.setSensorProperties( - ContextBase::mSap_conf.GYRO_BIAS_RANDOM_WALK_VALID, - ContextBase::mSap_conf.GYRO_BIAS_RANDOM_WALK, - ContextBase::mSap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY_VALID, - ContextBase::mSap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY, - ContextBase::mSap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY_VALID, - ContextBase::mSap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY, - ContextBase::mSap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY_VALID, - ContextBase::mSap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY, - ContextBase::mSap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY_VALID, - ContextBase::mSap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY); - } - mApi.setSensorPerfControlConfig( - ContextBase::mSap_conf.SENSOR_CONTROL_MODE, - ContextBase::mSap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH, - ContextBase::mSap_conf.SENSOR_ACCEL_BATCHES_PER_SEC, - ContextBase::mSap_conf.SENSOR_GYRO_SAMPLES_PER_BATCH, - ContextBase::mSap_conf.SENSOR_GYRO_BATCHES_PER_SEC, - ContextBase::mSap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH_HIGH, - ContextBase::mSap_conf.SENSOR_ACCEL_BATCHES_PER_SEC_HIGH, - ContextBase::mSap_conf.SENSOR_GYRO_SAMPLES_PER_BATCH_HIGH, - ContextBase::mSap_conf.SENSOR_GYRO_BATCHES_PER_SEC_HIGH, - ContextBase::mSap_conf.SENSOR_ALGORITHM_CONFIG_MASK); + std::string oldServerUrl = mAdapter.getServerUrl(); + mAdapter.setSuplHostServer(ContextBase::mGps_conf.SUPL_HOST, + ContextBase::mGps_conf.SUPL_PORT); + + // inject the configurations into modem + GnssAdapter& adapter = mAdapter; + loc_gps_cfg_s gpsConf = ContextBase::mGps_conf; + loc_sap_cfg_s_type sapConf = ContextBase::mSap_conf; + + mApi.sendMsg(new LocApiMsg( + [&adapter, gpsConf, sapConf, oldServerUrl] () { + + std::string serverUrl = adapter.getServerUrl(); + int serverUrlLen = serverUrl.length(); + + if (gpsConf.AGPS_CONFIG_INJECT) { + adapter.mLocApi->setSUPLVersionSync( + adapter.mLocApi->convertSuplVersion(gpsConf.SUPL_VER)); + adapter.mLocApi->setLPPConfigSync( + adapter.mLocApi->convertLppProfile(gpsConf.LPP_PROFILE)); + adapter.mLocApi->setAGLONASSProtocolSync( + gpsConf.A_GLONASS_POS_PROTOCOL_SELECT); + } + + if ((serverUrlLen !=0) && (oldServerUrl.compare(serverUrl) != 0)) { + LocationError locErr = + adapter.mLocApi->setServerSync(serverUrl.c_str(), serverUrlLen); + if (locErr != LOCATION_ERROR_SUCCESS) { + LOC_LOGE("%s]:Error while setting SUPL_HOST server:%s", + __func__, serverUrl.c_str()); + } + } + + adapter.mLocApi->setSensorControlConfigSync(sapConf.SENSOR_USAGE, + sapConf.SENSOR_PROVIDER); + adapter.mLocApi->setLPPeProtocolCpSync( + adapter.mLocApi->convertLppeCp(gpsConf.LPPE_CP_TECHNOLOGY)); + adapter.mLocApi->setLPPeProtocolUpSync( + adapter.mLocApi->convertLppeUp(gpsConf.LPPE_UP_TECHNOLOGY)); + + // set nmea mask type + uint32_t mask = 0; + if (NMEA_PROVIDER_MP == gpsConf.NMEA_PROVIDER) { + mask |= LOC_NMEA_ALL_GENERAL_SUPPORTED_MASK; + } + if (ContextBase::isFeatureSupported(LOC_SUPPORTED_FEATURE_DEBUG_NMEA_V02)) { + mask |= LOC_NMEA_MASK_DEBUG_V02; + } + + if (mask != 0) { + adapter.mLocApi->setNMEATypesSync(mask); + } + + adapter.mLocApi->setXtraVersionCheckSync(gpsConf.XTRA_VERSION_CHECK); + if (sapConf.GYRO_BIAS_RANDOM_WALK_VALID || + sapConf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY_VALID || + sapConf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY_VALID || + sapConf.RATE_RANDOM_WALK_SPECTRAL_DENSITY_VALID || + sapConf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY_VALID ) { + adapter.mLocApi->setSensorPropertiesSync( + sapConf.GYRO_BIAS_RANDOM_WALK_VALID, + sapConf.GYRO_BIAS_RANDOM_WALK, + sapConf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY_VALID, + sapConf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY, + sapConf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY_VALID, + sapConf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY, + sapConf.RATE_RANDOM_WALK_SPECTRAL_DENSITY_VALID, + sapConf.RATE_RANDOM_WALK_SPECTRAL_DENSITY, + sapConf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY_VALID, + sapConf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY); + } + adapter.mLocApi->setSensorPerfControlConfigSync( + sapConf.SENSOR_CONTROL_MODE, + sapConf.SENSOR_ACCEL_SAMPLES_PER_BATCH, + sapConf.SENSOR_ACCEL_BATCHES_PER_SEC, + sapConf.SENSOR_GYRO_SAMPLES_PER_BATCH, + sapConf.SENSOR_GYRO_BATCHES_PER_SEC, + sapConf.SENSOR_ACCEL_SAMPLES_PER_BATCH_HIGH, + sapConf.SENSOR_ACCEL_BATCHES_PER_SEC_HIGH, + sapConf.SENSOR_GYRO_SAMPLES_PER_BATCH_HIGH, + sapConf.SENSOR_GYRO_BATCHES_PER_SEC_HIGH, + sapConf.SENSOR_ALGORITHM_CONFIG_MASK); + } )); } }; @@ -783,8 +744,8 @@ GnssAdapter::gnssUpdateConfigCommand(GnssConfig config) GnssAdapter& mAdapter; LocApiBase& mApi; GnssConfig mConfig; - uint32_t* mIds; size_t mCount; + uint32_t* mIds; inline MsgGnssUpdateConfig(GnssAdapter& adapter, LocApiBase& api, GnssConfig config, @@ -794,163 +755,260 @@ GnssAdapter::gnssUpdateConfigCommand(GnssConfig config) mAdapter(adapter), mApi(api), mConfig(config), - mIds(ids), - mCount(count) {} + mCount(count), + mIds(ids) {} inline virtual ~MsgGnssUpdateConfig() { - delete[] mIds; + delete [] mIds; } + inline virtual void proc() const { - LocationError* errs = new LocationError[mCount]; - LocationError err = LOCATION_ERROR_SUCCESS; - uint32_t index = 0; - if (errs == nullptr) { - LOC_LOGE("%s] new allocation failed, fatal error.", __func__); - return; - } + GnssAdapter& adapter = mAdapter; + size_t countOfConfigs = mCount; + GnssConfig gnssConfigRequested = mConfig; + GnssConfig gnssConfigNeedEngineUpdate = mConfig; + std::string oldServerUrl = mAdapter.getServerUrl(); - if (mConfig.flags & GNSS_CONFIG_FLAGS_GPS_LOCK_VALID_BIT) { - uint32_t newGpsLock = mAdapter.convertGpsLock(mConfig.gpsLock); + std::vector sessionIds; + sessionIds.assign(mIds, mIds + mCount); + std::vector errs(mCount, LOCATION_ERROR_SUCCESS); + int index = 0; + + if (gnssConfigRequested.flags & GNSS_CONFIG_FLAGS_GPS_LOCK_VALID_BIT) { + index++; + uint32_t newGpsLock = mAdapter.convertGpsLock(gnssConfigRequested.gpsLock); ContextBase::mGps_conf.GPS_LOCK = newGpsLock; - if (0 == mAdapter.getPowerVoteId()) { - err = mApi.setGpsLock(mConfig.gpsLock); - } - if (index < mCount) { - errs[index++] = err; + if (0 != mAdapter.getPowerVoteId()) { + gnssConfigNeedEngineUpdate.flags &= ~(GNSS_CONFIG_FLAGS_GPS_LOCK_VALID_BIT); } } - if (mConfig.flags & GNSS_CONFIG_FLAGS_SUPL_VERSION_VALID_BIT) { - uint32_t newSuplVersion = mAdapter.convertSuplVersion(mConfig.suplVersion); + if (gnssConfigRequested.flags & GNSS_CONFIG_FLAGS_SUPL_VERSION_VALID_BIT) { + index++; + uint32_t newSuplVersion = + mAdapter.convertSuplVersion(gnssConfigRequested.suplVersion); if (newSuplVersion != ContextBase::mGps_conf.SUPL_VER && ContextBase::mGps_conf.AGPS_CONFIG_INJECT) { ContextBase::mGps_conf.SUPL_VER = newSuplVersion; - err = mApi.setSUPLVersion(mConfig.suplVersion); } else { - err = LOCATION_ERROR_SUCCESS; - } - if (index < mCount) { - errs[index++] = err; + gnssConfigNeedEngineUpdate.flags &= ~(GNSS_CONFIG_FLAGS_SUPL_VERSION_VALID_BIT); } } - if (mConfig.flags & GNSS_CONFIG_FLAGS_SET_ASSISTANCE_DATA_VALID_BIT) { + if (gnssConfigRequested.flags & GNSS_CONFIG_FLAGS_SET_ASSISTANCE_DATA_VALID_BIT) { + index++; if (GNSS_ASSISTANCE_TYPE_SUPL == mConfig.assistanceServer.type) { - err = mAdapter.setSuplHostServer(mConfig.assistanceServer.hostName, - mConfig.assistanceServer.port); - } else if (GNSS_ASSISTANCE_TYPE_C2K == mConfig.assistanceServer.type) { - if (ContextBase::mGps_conf.AGPS_CONFIG_INJECT) { - struct in_addr addr; - if (!mAdapter.resolveInAddress(mConfig.assistanceServer.hostName, - &addr)) { - LOC_LOGE("%s]: hostName %s cannot be resolved", - __func__, mConfig.assistanceServer.hostName); - err = LOCATION_ERROR_INVALID_PARAMETER; - } else { - unsigned int ip = htonl(addr.s_addr); - err = mApi.setServer(ip, mConfig.assistanceServer.port, - LOC_AGPS_CDMA_PDE_SERVER); - } - } else { - err = LOCATION_ERROR_SUCCESS; - } - } else { + mAdapter.setSuplHostServer(mConfig.assistanceServer.hostName, + mConfig.assistanceServer.port); + } else if (GNSS_ASSISTANCE_TYPE_C2K != mConfig.assistanceServer.type) { LOC_LOGE("%s]: Not a valid gnss assistance type %u", - __func__, mConfig.assistanceServer.type); - err = LOCATION_ERROR_INVALID_PARAMETER; - } - if (index < mCount) { - errs[index++] = err; + __func__, mConfig.assistanceServer.type); + errs.at(index) = LOCATION_ERROR_INVALID_PARAMETER; + gnssConfigNeedEngineUpdate.flags &= + ~(GNSS_CONFIG_FLAGS_SET_ASSISTANCE_DATA_VALID_BIT); } } - if (mConfig.flags & GNSS_CONFIG_FLAGS_LPP_PROFILE_VALID_BIT) { - uint32_t newLppProfile = mAdapter.convertLppProfile(mConfig.lppProfile); + if (gnssConfigRequested.flags & GNSS_CONFIG_FLAGS_LPP_PROFILE_VALID_BIT) { + index++; + uint32_t newLppProfile = mAdapter.convertLppProfile(gnssConfigRequested.lppProfile); if (newLppProfile != ContextBase::mGps_conf.LPP_PROFILE && ContextBase::mGps_conf.AGPS_CONFIG_INJECT) { ContextBase::mGps_conf.LPP_PROFILE = newLppProfile; - err = mApi.setLPPConfig(mConfig.lppProfile); } else { - err = LOCATION_ERROR_SUCCESS; - } - if (index < mCount) { - errs[index++] = err; + gnssConfigNeedEngineUpdate.flags &= ~(GNSS_CONFIG_FLAGS_LPP_PROFILE_VALID_BIT); } } - if (mConfig.flags & GNSS_CONFIG_FLAGS_LPPE_CONTROL_PLANE_VALID_BIT) { + if (gnssConfigRequested.flags & GNSS_CONFIG_FLAGS_LPPE_CONTROL_PLANE_VALID_BIT) { + index++; uint32_t newLppeControlPlaneMask = - mAdapter.convertLppeCp(mConfig.lppeControlPlaneMask); + mAdapter.convertLppeCp(gnssConfigRequested.lppeControlPlaneMask); if (newLppeControlPlaneMask != ContextBase::mGps_conf.LPPE_CP_TECHNOLOGY) { ContextBase::mGps_conf.LPPE_CP_TECHNOLOGY = newLppeControlPlaneMask; - err = mApi.setLPPeProtocolCp(mConfig.lppeControlPlaneMask); } else { - err = LOCATION_ERROR_SUCCESS; - } - if (index < mCount) { - errs[index++] = err; + gnssConfigNeedEngineUpdate.flags &= + ~(GNSS_CONFIG_FLAGS_LPPE_CONTROL_PLANE_VALID_BIT); } } - if (mConfig.flags & GNSS_CONFIG_FLAGS_LPPE_USER_PLANE_VALID_BIT) { + if (gnssConfigRequested.flags & GNSS_CONFIG_FLAGS_LPPE_USER_PLANE_VALID_BIT) { + index++; uint32_t newLppeUserPlaneMask = - mAdapter.convertLppeUp(mConfig.lppeUserPlaneMask); + mAdapter.convertLppeUp(gnssConfigRequested.lppeUserPlaneMask); if (newLppeUserPlaneMask != ContextBase::mGps_conf.LPPE_UP_TECHNOLOGY) { ContextBase::mGps_conf.LPPE_UP_TECHNOLOGY = newLppeUserPlaneMask; - err = mApi.setLPPeProtocolUp(mConfig.lppeUserPlaneMask); } else { - err = LOCATION_ERROR_SUCCESS; - } - if (index < mCount) { - errs[index++] = err; + gnssConfigNeedEngineUpdate.flags &= + ~(GNSS_CONFIG_FLAGS_LPPE_USER_PLANE_VALID_BIT); } } - if (mConfig.flags & GNSS_CONFIG_FLAGS_AGLONASS_POSITION_PROTOCOL_VALID_BIT) { + if (gnssConfigRequested.flags & + GNSS_CONFIG_FLAGS_AGLONASS_POSITION_PROTOCOL_VALID_BIT) { + index++; uint32_t newAGloProtMask = - mAdapter.convertAGloProt(mConfig.aGlonassPositionProtocolMask); + mAdapter.convertAGloProt(gnssConfigRequested.aGlonassPositionProtocolMask); if (newAGloProtMask != ContextBase::mGps_conf.A_GLONASS_POS_PROTOCOL_SELECT && ContextBase::mGps_conf.AGPS_CONFIG_INJECT) { ContextBase::mGps_conf.A_GLONASS_POS_PROTOCOL_SELECT = newAGloProtMask; - err = mApi.setAGLONASSProtocol(mConfig.aGlonassPositionProtocolMask); } else { - err = LOCATION_ERROR_SUCCESS; + gnssConfigNeedEngineUpdate.flags &= + ~(GNSS_CONFIG_FLAGS_AGLONASS_POSITION_PROTOCOL_VALID_BIT); } - if (index < mCount) { - errs[index++] = err; - } - } - if (mConfig.flags & GNSS_CONFIG_FLAGS_EM_PDN_FOR_EM_SUPL_VALID_BIT) { - uint32_t newEP4ES = mAdapter.convertEP4ES(mConfig.emergencyPdnForEmergencySupl); + } + if (gnssConfigRequested.flags & GNSS_CONFIG_FLAGS_EM_PDN_FOR_EM_SUPL_VALID_BIT) { + index++; + uint32_t newEP4ES = mAdapter.convertEP4ES( + gnssConfigRequested.emergencyPdnForEmergencySupl); if (newEP4ES != ContextBase::mGps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL) { ContextBase::mGps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL = newEP4ES; } - err = LOCATION_ERROR_SUCCESS; - if (index < mCount) { - errs[index++] = err; - } - } - if (mConfig.flags & GNSS_CONFIG_FLAGS_SUPL_EM_SERVICES_BIT) { - uint32_t newSuplEs = mAdapter.convertSuplEs(mConfig.suplEmergencyServices); + } + if (gnssConfigRequested.flags & GNSS_CONFIG_FLAGS_SUPL_EM_SERVICES_BIT) { + index++; + uint32_t newSuplEs = mAdapter.convertSuplEs( + gnssConfigRequested.suplEmergencyServices); if (newSuplEs != ContextBase::mGps_conf.SUPL_ES) { ContextBase::mGps_conf.SUPL_ES = newSuplEs; } - err = LOCATION_ERROR_SUCCESS; - if (index < mCount) { - errs[index++] = err; - } - } - if (mConfig.flags & GNSS_CONFIG_FLAGS_SUPL_MODE_BIT) { - uint32_t newSuplMode = mAdapter.convertSuplMode(mConfig.suplModeMask); + } + if (gnssConfigRequested.flags & GNSS_CONFIG_FLAGS_SUPL_MODE_BIT) { + index++; + uint32_t newSuplMode = mAdapter.convertSuplMode(gnssConfigRequested.suplModeMask); if (newSuplMode != ContextBase::mGps_conf.SUPL_MODE) { ContextBase::mGps_conf.SUPL_MODE = newSuplMode; mAdapter.getUlpProxy()->setCapabilities( ContextBase::getCarrierCapabilities()); mAdapter.broadcastCapabilities(mAdapter.getCapabilities()); } - err = LOCATION_ERROR_SUCCESS; - if (index < mCount) { - errs[index++] = err; - } } - mAdapter.reportResponse(index, errs, mIds); - delete[] errs; + LocApiCollectiveResponse *configCollectiveResponse = new LocApiCollectiveResponse( + *adapter.getContext(), + [&adapter, sessionIds, countOfConfigs] (std::vector errs) { + + std::vector ids(sessionIds); + adapter.reportResponse(countOfConfigs, errs.data(), ids.data()); + }); + + mApi.sendMsg(new LocApiMsg( + [&adapter, gnssConfigRequested, gnssConfigNeedEngineUpdate, + countOfConfigs, configCollectiveResponse, errs, oldServerUrl] () { + + size_t index = 0; + LocationError err = LOCATION_ERROR_SUCCESS; + std::vector errsList(errs); + + std::string serverUrl = adapter.getServerUrl(); + int serverUrlLen = serverUrl.length(); + + if (gnssConfigRequested.flags & GNSS_CONFIG_FLAGS_GPS_LOCK_VALID_BIT) { + if (gnssConfigNeedEngineUpdate.flags & GNSS_CONFIG_FLAGS_GPS_LOCK_VALID_BIT) { + err = adapter.mLocApi->setGpsLockSync(gnssConfigRequested.gpsLock); + if (index < countOfConfigs) { + errsList[index] = err; + } + } + } + if (gnssConfigRequested.flags & + GNSS_CONFIG_FLAGS_SET_ASSISTANCE_DATA_VALID_BIT) { + index++; + if (gnssConfigNeedEngineUpdate.flags & + GNSS_CONFIG_FLAGS_SET_ASSISTANCE_DATA_VALID_BIT) { + if (gnssConfigNeedEngineUpdate.assistanceServer.type == + GNSS_ASSISTANCE_TYPE_SUPL) { + if ((serverUrlLen != 0) && (oldServerUrl.compare(serverUrl) !=0)) { + err = adapter.mLocApi->setServerSync( + serverUrl.c_str(), serverUrlLen); + errsList[index] = err; + } + } else if (gnssConfigNeedEngineUpdate.assistanceServer.type == + GNSS_ASSISTANCE_TYPE_C2K) { + struct in_addr addr; + struct hostent* hp; + bool resolveAddrSuccess = true; + + hp = gethostbyname( + gnssConfigNeedEngineUpdate.assistanceServer.hostName); + if (hp != NULL) { /* DNS OK */ + memcpy(&addr, hp->h_addr_list[0], hp->h_length); + } else { + /* Try IP representation */ + if (inet_aton( + gnssConfigNeedEngineUpdate.assistanceServer.hostName, + &addr) == 0) { + /* IP not valid */ + LOC_LOGE("%s]: hostname '%s' cannot be resolved ", + __func__, + gnssConfigNeedEngineUpdate.assistanceServer.hostName); + errsList[index] = LOCATION_ERROR_INVALID_PARAMETER; + } else { + resolveAddrSuccess = false; + } + } + + if (resolveAddrSuccess) { + unsigned int ip = htonl(addr.s_addr); + err = adapter.mLocApi->setServerSync(ip, + gnssConfigNeedEngineUpdate.assistanceServer.port, + LOC_AGPS_CDMA_PDE_SERVER); + errsList[index] = err; + } + } + } + } + if (gnssConfigRequested.flags & GNSS_CONFIG_FLAGS_SUPL_VERSION_VALID_BIT) { + index++; + if (gnssConfigNeedEngineUpdate.flags & + GNSS_CONFIG_FLAGS_SUPL_VERSION_VALID_BIT) { + err = adapter.mLocApi->setSUPLVersionSync(gnssConfigRequested.suplVersion); + if (index < countOfConfigs) { + errsList[index] = err; + } + } + } + if (gnssConfigRequested.flags & GNSS_CONFIG_FLAGS_LPP_PROFILE_VALID_BIT) { + index++; + if (gnssConfigNeedEngineUpdate.flags & + GNSS_CONFIG_FLAGS_LPP_PROFILE_VALID_BIT) { + err = adapter.mLocApi->setLPPConfigSync(gnssConfigRequested.lppProfile); + if (index < countOfConfigs) { + errsList[index] = err; + } + } + } + if (gnssConfigRequested.flags & GNSS_CONFIG_FLAGS_LPPE_CONTROL_PLANE_VALID_BIT) { + index++; + if (gnssConfigNeedEngineUpdate.flags & + GNSS_CONFIG_FLAGS_LPPE_CONTROL_PLANE_VALID_BIT) { + err = adapter.mLocApi->setLPPeProtocolCpSync( + gnssConfigRequested.lppeControlPlaneMask); + if (index < countOfConfigs) { + errsList[index] = err; + } + } + } + if (gnssConfigRequested.flags & GNSS_CONFIG_FLAGS_LPPE_USER_PLANE_VALID_BIT) { + index++; + if (gnssConfigNeedEngineUpdate.flags & + GNSS_CONFIG_FLAGS_LPPE_USER_PLANE_VALID_BIT) { + err = adapter.mLocApi->setLPPeProtocolUpSync( + gnssConfigRequested.lppeUserPlaneMask); + if (index < countOfConfigs) { + errsList[index] = err; + } + } + } + if (gnssConfigRequested.flags & + GNSS_CONFIG_FLAGS_AGLONASS_POSITION_PROTOCOL_VALID_BIT) { + index++; + if (gnssConfigNeedEngineUpdate.flags & + GNSS_CONFIG_FLAGS_AGLONASS_POSITION_PROTOCOL_VALID_BIT) { + err = adapter.mLocApi->setAGLONASSProtocolSync( + gnssConfigRequested.aGlonassPositionProtocolMask); + if (index < countOfConfigs) { + errsList[index] = err; + } + } + } + configCollectiveResponse->returnToSender(errsList); + })); } }; @@ -963,6 +1021,13 @@ GnssAdapter::gnssUpdateConfigCommand(GnssConfig config) return ids; } +void GnssAdapter::deleteAidingData(const GnssAidingData &data, uint32_t sessionId) { + mLocApi->deleteAidingData(data, new LocApiResponse(*getContext(), + [this, sessionId] (LocationError err) { + reportResponse(err, sessionId); + })); +} + uint32_t GnssAdapter::gnssDeleteAidingDataCommand(GnssAidingData& data) { @@ -971,22 +1036,18 @@ GnssAdapter::gnssDeleteAidingDataCommand(GnssAidingData& data) struct MsgDeleteAidingData : public LocMsg { GnssAdapter& mAdapter; - LocApiBase& mApi; uint32_t mSessionId; GnssAidingData mData; inline MsgDeleteAidingData(GnssAdapter& adapter, - LocApiBase& api, uint32_t sessionId, GnssAidingData& data) : LocMsg(), mAdapter(adapter), - mApi(api), mSessionId(sessionId), mData(data) {} inline virtual void proc() const { - LocationError err = LOCATION_ERROR_SUCCESS; - err = mApi.deleteAidingData(mData); - mAdapter.reportResponse(err, mSessionId); + mAdapter.deleteAidingData(mData, mSessionId); + SystemStatus* s = mAdapter.getSystemStatus(); if ((nullptr != s) && (mData.deleteAll)) { s->setDefaultGnssEngineStates(); @@ -995,7 +1056,7 @@ GnssAdapter::gnssDeleteAidingDataCommand(GnssAidingData& data) } }; - sendMsg(new MsgDeleteAidingData(*this, *mLocApi, sessionId, data)); + sendMsg(new MsgDeleteAidingData(*this, sessionId, data)); return sessionId; } @@ -1187,11 +1248,9 @@ GnssAdapter::stopClientSessions(LocationAPI* client) LOC_LOGD("%s]: client %p", __func__, client); for (auto it = mTrackingSessions.begin(); it != mTrackingSessions.end();) { if (client == it->first.client) { - LocationError err = stopTrackingMultiplex(it->first.client, it->first.id); - if (LOCATION_ERROR_SUCCESS == err) { - it = mTrackingSessions.erase(it); - continue; - } + stopTrackingMultiplex(it->first.client, it->first.id); + it = mTrackingSessions.erase(it); + continue; } ++it; // increment only when not erasing an iterator } @@ -1244,18 +1303,23 @@ GnssAdapter::updateClientsEventMask() void GnssAdapter::handleEngineUpEvent() { - struct MsgRestartSessions : public LocMsg { + LOC_LOGD("%s]: ", __func__); + + struct MsgHandleEngineUpEvent : public LocMsg { GnssAdapter& mAdapter; - inline MsgRestartSessions(GnssAdapter& adapter) : + inline MsgHandleEngineUpEvent(GnssAdapter& adapter) : LocMsg(), mAdapter(adapter) {} virtual void proc() const { + mAdapter.broadcastCapabilities(mAdapter.getCapabilities()); + // restart sessions mAdapter.restartSessions(); } }; + readConfigCommand(); setConfigCommand(); - sendMsg(new MsgRestartSessions(*this)); + sendMsg(new MsgHandleEngineUpEvent(*this)); } void @@ -1279,11 +1343,9 @@ GnssAdapter::restartSessions() LocPosMode locPosMode = {}; convertOptions(locPosMode, smallestIntervalOptions); - // inform engine hub of the fix mode and start session - mEngHubProxy->gnssSetFixMode(locPosMode); - mEngHubProxy->gnssStartFix(); - - mLocApi->startFix(locPosMode); + mLocApi->startFix(locPosMode, new LocApiResponse(*getContext(), + [] (LocationError err) {} + )); } void @@ -1306,12 +1368,14 @@ GnssAdapter::requestCapabilitiesCommand(LocationAPI* client) return; } - LocationCapabilitiesMask mask = mAdapter.getCapabilities(); - callbacks.capabilitiesCb(mask); + LocationCapabilitiesMask mask = mAdapter.getCapabilities(); + callbacks.capabilitiesCb(mask); } }; - sendMsg(new MsgRequestCapabilities(*this, client)); + if (ContextBase::isEngineCapabilitiesKnown()) { + sendMsg(new MsgRequestCapabilities(*this, client)); + } } LocationCapabilitiesMask @@ -1329,22 +1393,20 @@ GnssAdapter::getCapabilities() if (LOC_GPS_CAPABILITY_MSA & carrierCapabilities) { mask |= LOCATION_CAPABILITIES_GNSS_MSA_BIT; } - if (mLocApi == nullptr) - return mask; - if (mLocApi->isMessageSupported(LOC_API_ADAPTER_MESSAGE_DISTANCE_BASE_LOCATION_BATCHING)) { + if (ContextBase::isMessageSupported(LOC_API_ADAPTER_MESSAGE_DISTANCE_BASE_LOCATION_BATCHING)) { mask |= LOCATION_CAPABILITIES_TIME_BASED_BATCHING_BIT | LOCATION_CAPABILITIES_DISTANCE_BASED_BATCHING_BIT; } - if (mLocApi->isMessageSupported(LOC_API_ADAPTER_MESSAGE_DISTANCE_BASE_TRACKING)) { + if (ContextBase::isMessageSupported(LOC_API_ADAPTER_MESSAGE_DISTANCE_BASE_TRACKING)) { mask |= LOCATION_CAPABILITIES_DISTANCE_BASED_TRACKING_BIT; } - if (mLocApi->isMessageSupported(LOC_API_ADAPTER_MESSAGE_OUTDOOR_TRIP_BATCHING)) { + if (ContextBase::isMessageSupported(LOC_API_ADAPTER_MESSAGE_OUTDOOR_TRIP_BATCHING)) { mask |= LOCATION_CAPABILITIES_OUTDOOR_TRIP_BATCHING_BIT; } - if (mLocApi->gnssConstellationConfig()) { + if (ContextBase::gnssConstellationConfig()) { mask |= LOCATION_CAPABILITIES_GNSS_MEASUREMENTS_BIT; } - if (mLocApi->isFeatureSupported(LOC_SUPPORTED_FEATURE_DEBUG_NMEA_V02)) { + if (ContextBase::isFeatureSupported(LOC_SUPPORTED_FEATURE_DEBUG_NMEA_V02)) { mask |= LOCATION_CAPABILITIES_DEBUG_NMEA_BIT; } return mask; @@ -1353,9 +1415,9 @@ GnssAdapter::getCapabilities() void GnssAdapter::broadcastCapabilities(LocationCapabilitiesMask mask) { - for (auto it = mClientData.begin(); it != mClientData.end(); ++it) { - if (nullptr != it->second.capabilitiesCb) { - it->second.capabilitiesCb(mask); + for (auto clientData : mClientData) { + if (nullptr != clientData.second.capabilitiesCb) { + clientData.second.capabilitiesCb(mask); } } } @@ -1443,8 +1505,7 @@ GnssAdapter::reportResponse(LocationAPI* client, LocationError err, uint32_t ses LOC_LOGD("%s]: client %p id %u err %u", __func__, client, sessionId, err); auto it = mClientData.find(client); - if (it != mClientData.end() && - it->second.responseCb != nullptr) { + if (it != mClientData.end() && it->second.responseCb != nullptr) { it->second.responseCb(err, sessionId); } else { LOC_LOGW("%s]: client %p id %u not found in data", __func__, client, sessionId); @@ -1522,12 +1583,14 @@ GnssAdapter::startTrackingCommand(LocationAPI* client, LocationOptions& options) err = LOCATION_ERROR_INVALID_PARAMETER; } else { // Api doesn't support multiple clients for time based tracking, so mutiplex - err = mAdapter.startTrackingMultiplex(mOptions); - if (LOCATION_ERROR_SUCCESS == err) { - mAdapter.saveTrackingSession(mClient, mSessionId, mOptions); + bool reportToClientWithNoWait = + mAdapter.startTrackingMultiplex(mClient, mSessionId, mOptions); + mAdapter.saveTrackingSession(mClient, mSessionId, mOptions); + + if (reportToClientWithNoWait) { + mAdapter.reportResponse(mClient, LOCATION_ERROR_SUCCESS, mSessionId); } } - mAdapter.reportResponse(mClient, err, mSessionId); } }; @@ -1536,13 +1599,14 @@ GnssAdapter::startTrackingCommand(LocationAPI* client, LocationOptions& options) } -LocationError -GnssAdapter::startTrackingMultiplex(const LocationOptions& options) +bool +GnssAdapter::startTrackingMultiplex(LocationAPI* client, uint32_t sessionId, + const LocationOptions& options) { - LocationError err = LOCATION_ERROR_SUCCESS; + bool reportToClientWithNoWait = true; if (mTrackingSessions.empty()) { - err = startTracking(options); + reportToClientWithNoWait = startTracking(client, sessionId, options); } else { // get the LocationOptions that has the smallest interval, which should be the active one LocationOptions smallestIntervalOptions = {}; // size is zero until set for the first time @@ -1555,17 +1619,19 @@ GnssAdapter::startTrackingMultiplex(const LocationOptions& options) // if new session's minInterval is smaller than any in other sessions if (options.minInterval < smallestIntervalOptions.minInterval) { // restart time based tracking with new options - err = startTracking(options); + reportToClientWithNoWait = startTracking(client, sessionId, options); } } - return err; + return reportToClientWithNoWait; } -LocationError -GnssAdapter::startTracking(const LocationOptions& options) +bool +GnssAdapter::startTracking(LocationAPI* client, uint32_t sessionId, + const LocationOptions& options) { - LocationError err = LOCATION_ERROR_SUCCESS; + bool reportToClientWithNoWait = true; + LocPosMode locPosMode = {}; convertOptions(locPosMode, options); if (!mUlpProxy->sendFixMode(locPosMode)) { @@ -1576,17 +1642,56 @@ GnssAdapter::startTracking(const LocationOptions& options) mEngHubProxy->gnssSetFixMode(locPosMode); mEngHubProxy->gnssStartFix(); - loc_api_adapter_err apiErr = mLocApi->startFix(locPosMode); - if (LOC_API_ADAPTER_ERR_SUCCESS == apiErr) { - err = LOCATION_ERROR_SUCCESS; - } else { - err = LOCATION_ERROR_GENERAL_FAILURE; - } + mLocApi->startFix(locPosMode, new LocApiResponse(*getContext(), + [this, client, sessionId] (LocationError err) { + if (LOCATION_ERROR_SUCCESS != err) { + eraseTrackingSession(client, sessionId); + } + + reportResponse(client, err, sessionId); + } + )); + + reportToClientWithNoWait = false; } - return err; + return reportToClientWithNoWait; } +bool +GnssAdapter::updateTracking(LocationAPI* client, uint32_t sessionId, + const LocationOptions& updatedOptions, const LocationOptions& oldOptions) +{ + bool reportToClientWithNoWait = true; + + LocPosMode locPosMode = {}; + convertOptions(locPosMode, updatedOptions); + if (!mUlpProxy->sendFixMode(locPosMode)) { + // do nothing + } + if (!mUlpProxy->sendStartFix()) { + // inform engine hub that GNSS session is about to start + mEngHubProxy->gnssSetFixMode(locPosMode); + mEngHubProxy->gnssStartFix(); + + mLocApi->startFix(locPosMode, new LocApiResponse(*getContext(), + [this, client, sessionId, oldOptions] (LocationError err) { + if (LOCATION_ERROR_SUCCESS != err) { + // restore the old LocationOptions + saveTrackingSession(client, sessionId, oldOptions); + } + + reportResponse(client, err, sessionId); + } + )); + + reportToClientWithNoWait = false; + } + + return reportToClientWithNoWait; +} + + void GnssAdapter::setPositionModeCommand(LocPosMode& locPosMode) { @@ -1640,8 +1745,11 @@ GnssAdapter::startTrackingCommand() // inform engine hub of the fix mode and start session mAdapter.mEngHubProxy->gnssSetFixMode(ulpPositionMode); mAdapter.mEngHubProxy->gnssStartFix(); - if (!mAdapter.isInSession()) { - mApi.startFix(ulpPositionMode); + if (!mAdapter.isInSession()) { + LocPosMode& ulpPositionMode = mAdapter.getUlpPositionMode(); + mApi.startFix(ulpPositionMode, new LocApiResponse(*mAdapter.getContext(), + [] (LocationError err) {} + )); } } }; @@ -1680,12 +1788,14 @@ GnssAdapter::updateTrackingOptionsCommand(LocationAPI* client, uint32_t id, err = LOCATION_ERROR_INVALID_PARAMETER; } else { // Api doesn't support multiple clients for time based tracking, so mutiplex - err = mAdapter.updateTrackingMultiplex(mClient, mSessionId, mOptions); - if (LOCATION_ERROR_SUCCESS == err) { - mAdapter.saveTrackingSession(mClient, mSessionId, mOptions); + bool reportToClientWithNoWait = + mAdapter.updateTrackingMultiplex(mClient, mSessionId, mOptions); + mAdapter.saveTrackingSession(mClient, mSessionId, mOptions); + + if (reportToClientWithNoWait) { + mAdapter.reportResponse(mClient, err, mSessionId); } } - mAdapter.reportResponse(mClient, err, mSessionId); } // we do not reportResponse for the case where there is no existing tracking session // for the client and id being used, since updateTrackingCommand can be sent to both @@ -1696,19 +1806,21 @@ GnssAdapter::updateTrackingOptionsCommand(LocationAPI* client, uint32_t id, sendMsg(new MsgUpdateTracking(*this, *mLocApi, client, id, options)); } -LocationError +bool GnssAdapter::updateTrackingMultiplex(LocationAPI* client, uint32_t id, const LocationOptions& options) { - LocationError err = LOCATION_ERROR_SUCCESS; + bool reportToClientWithNoWait = true; + + LocationSessionKey key(client, id); + // get the session we are updating + auto it = mTrackingSessions.find(key); + // cache the clients existing LocationOptions + LocationOptions oldOptions = it->second; if (1 == mTrackingSessions.size()) { - err = startTracking(options); + reportToClientWithNoWait = updateTracking(client, id, options, oldOptions); } else { - LocationSessionKey key(client, id); - - // get the session we are updating - auto it = mTrackingSessions.find(key); if (it != mTrackingSessions.end()) { // find the smallest interval, other than the session we are updating LocationOptions smallestIntervalOptions = {}; // size is 0 until set for the first time @@ -1723,16 +1835,17 @@ GnssAdapter::updateTrackingMultiplex(LocationAPI* client, uint32_t id, // if session we are updating has smaller interval then next smallest if (options.minInterval < smallestIntervalOptions.minInterval) { // restart time based tracking with the newly updated interval - err = startTracking(options); + reportToClientWithNoWait = updateTracking(client, id, options, oldOptions); // else if the session we are updating used to be the smallest } else if (it->second.minInterval < smallestIntervalOptions.minInterval) { // restart time based tracking with the next smallest - err = startTracking(smallestIntervalOptions); + reportToClientWithNoWait = updateTracking( + client, id, smallestIntervalOptions, oldOptions); } } } - return err; + return reportToClientWithNoWait; } void @@ -1756,31 +1869,31 @@ GnssAdapter::stopTrackingCommand(LocationAPI* client, uint32_t id) mSessionId(sessionId) {} inline virtual void proc() const { if (mAdapter.isTrackingSession(mClient, mSessionId)) { - LocationError err = LOCATION_ERROR_SUCCESS; // Api doesn't support multiple clients for time based tracking, so mutiplex - err = mAdapter.stopTrackingMultiplex(mClient, mSessionId); - if (LOCATION_ERROR_SUCCESS == err) { - mAdapter.eraseTrackingSession(mClient, mSessionId); + bool reportToClientWithNoWait = + mAdapter.stopTrackingMultiplex(mClient, mSessionId); + mAdapter.eraseTrackingSession(mClient, mSessionId); + + if (reportToClientWithNoWait) { + mAdapter.reportResponse(mClient, LOCATION_ERROR_SUCCESS, mSessionId); } - mAdapter.reportResponse(mClient, err, mSessionId); } // we do not reportResponse for the case where there is no existing tracking session // for the client and id being used, since stopTrackingCommand can be sent to both // GnssAdapter & FlpAdapter by LocationAPI and we want to avoid incorrect error response - } }; sendMsg(new MsgStopTracking(*this, *mLocApi, client, id)); } -LocationError +bool GnssAdapter::stopTrackingMultiplex(LocationAPI* client, uint32_t id) { - LocationError err = LOCATION_ERROR_SUCCESS; + bool reportToClientWithNoWait = true; if (1 == mTrackingSessions.size()) { - err = stopTracking(); + reportToClientWithNoWait = stopTracking(client, id); } else { LocationSessionKey key(client, id); @@ -1800,31 +1913,32 @@ GnssAdapter::stopTrackingMultiplex(LocationAPI* client, uint32_t id) // if session we are stopping has smaller interval then next smallest if (it->second.minInterval < smallestIntervalOptions.minInterval) { // restart time based tracking with next smallest interval - err = startTracking(smallestIntervalOptions); + reportToClientWithNoWait = startTracking(client, id, smallestIntervalOptions); } } } - return err; + return reportToClientWithNoWait; } -LocationError -GnssAdapter::stopTracking() +bool +GnssAdapter::stopTracking(LocationAPI* client, uint32_t id) { - LocationError err = LOCATION_ERROR_SUCCESS; + bool reportToClientWithNoWait = true; + if (!mUlpProxy->sendStopFix()) { // inform engine hub that GNSS session has stopped mEngHubProxy->gnssStopFix(); - loc_api_adapter_err apiErr = mLocApi->stopFix(); - if (LOC_API_ADAPTER_ERR_SUCCESS == apiErr) { - err = LOCATION_ERROR_SUCCESS; - } else { - err = LOCATION_ERROR_GENERAL_FAILURE; - } + mLocApi->stopFix(new LocApiResponse(*getContext(), + [this, client, id] (LocationError err) { + reportResponse(client, err, id); + })); + + reportToClientWithNoWait = false; } - return err; + return reportToClientWithNoWait; } void @@ -1849,7 +1963,9 @@ GnssAdapter::stopTrackingCommand() mLocPosMode.mode = LOC_POSITION_MODE_INVALID; mAdapter.setUlpPositionMode(mLocPosMode); // don't need to multiplex because ULP will do that for us if it is present - mApi.stopFix(); + mApi.stopFix(new LocApiResponse(*mAdapter.getContext(), + [] (LocationError /* err*/) {} + )); } }; @@ -1870,24 +1986,12 @@ GnssAdapter::getZppCommand() mAdapter(adapter), mApi(api) {} inline virtual void proc() const { - UlpLocation location = {}; - LocPosTechMask techMask = LOC_POS_TECH_MASK_DEFAULT; - GpsLocationExtended locationExtended = {}; - locationExtended.size = sizeof(locationExtended); - - mApi.getBestAvailableZppFix(location.gpsLocation, locationExtended, - techMask); - //Mark the location source as from ZPP - location.gpsLocation.flags |= LOCATION_HAS_SOURCE_INFO; - location.position_source = ULP_LOCATION_IS_FROM_ZPP; - - mAdapter.getUlpProxy()->reportPosition(location, - locationExtended, - LOC_SESS_SUCCESS, - techMask); + mApi.getBestAvailableZppFix(); } }; + // TODO: we could avoid this extra context switch, as getBestAvailableZppFix + // will return asynchronously anyways. sendMsg(new MsgGetZpp(*this, *mLocApi)); } @@ -1971,28 +2075,28 @@ GnssAdapter::gnssNiResponseCommand(GnssNiResponse response, void* rawRequest) LOC_LOGD("%s]: response %u", __func__, response); struct MsgGnssNiResponse : public LocMsg { + GnssAdapter& mAdapter; LocApiBase& mApi; const GnssNiResponse mResponse; const void* mPayload; - inline MsgGnssNiResponse(LocApiBase& api, + inline MsgGnssNiResponse(GnssAdapter& adapter, + LocApiBase& api, const GnssNiResponse response, const void* rawRequest) : LocMsg(), + mAdapter(adapter), mApi(api), mResponse(response), mPayload(rawRequest) {} inline virtual ~MsgGnssNiResponse() { - // this is a bit weird since mPayload is not - // allocated by this class. But there is no better way. - // mPayload actually won't be NULL here. - free((void*)mPayload); } inline virtual void proc() const { + const void *rawPayload = mPayload; mApi.informNiResponse(mResponse, mPayload); } }; - sendMsg(new MsgGnssNiResponse(*mLocApi, response, rawRequest)); + sendMsg(new MsgGnssNiResponse(*this, *mLocApi, response, rawRequest)); } @@ -2029,7 +2133,11 @@ GnssAdapter::enableCommand(LocationTechnologyType techType) } else { mContext.modemPowerVote(true); mAdapter.setPowerVoteId(mSessionId); - mApi.setGpsLock(GNSS_CONFIG_GPS_LOCK_NONE); + + mApi.sendMsg(new LocApiMsg([&mApi = mApi] () { + mApi.setGpsLockSync(GNSS_CONFIG_GPS_LOCK_NONE); + })); + mAdapter.mXtraObserver.updateLockStatus( mAdapter.convertGpsLock(GNSS_CONFIG_GPS_LOCK_NONE)); } @@ -2073,7 +2181,12 @@ GnssAdapter::disableCommand(uint32_t id) } else { mContext.modemPowerVote(false); mAdapter.setPowerVoteId(0); - mApi.setGpsLock(mAdapter.convertGpsLock(ContextBase::mGps_conf.GPS_LOCK)); + + GnssConfigGpsLock gpsLock = + mAdapter.convertGpsLock(ContextBase::mGps_conf.GPS_LOCK); + mApi.sendMsg(new LocApiMsg([&mApi = mApi,gpsLock] () { + mApi.setGpsLockSync(gpsLock); + })); mAdapter.mXtraObserver.updateLockStatus( mAdapter.convertGpsLock(ContextBase::mGps_conf.GPS_LOCK)); } @@ -2810,6 +2923,41 @@ bool GnssAdapter::reportDataCallClosed(){ return true; } +bool GnssAdapter::reportZppBestAvailableFix(LocGpsLocation &zppLoc, + GpsLocationExtended &location_extended, LocPosTechMask tech_mask) { + + struct MsgReportZpp : public LocMsg { + GnssAdapter& mAdapter; + UlpLocation mUlpLocation; + GpsLocationExtended mGpsLocationExtended; + LocPosTechMask mPosTechMask; + + inline MsgReportZpp(GnssAdapter& adapter, + LocGpsLocation &zppLoc, GpsLocationExtended &location_extended, + LocPosTechMask tech_mask) : + LocMsg(), + mAdapter(adapter), + mGpsLocationExtended(location_extended), + mPosTechMask(tech_mask) { + mUlpLocation = {}; + memcpy(&mUlpLocation.gpsLocation, &zppLoc, sizeof(LocGpsLocation)); + + //Mark the location source as from ZPP + mUlpLocation.gpsLocation.flags |= LOCATION_HAS_SOURCE_INFO; + mUlpLocation.position_source = ULP_LOCATION_IS_FROM_ZPP; + } + inline virtual void proc() const { + mAdapter.getUlpProxy()->reportPosition(mUlpLocation, + mGpsLocationExtended, + LOC_SESS_SUCCESS, + mPosTechMask); + } + }; + + sendMsg(new MsgReportZpp(*this, zppLoc, location_extended, tech_mask)); + return true; +} + void GnssAdapter::dataConnOpenCommand( AGpsExtType agpsType, const char* apnName, int apnLen, AGpsBearerType bearerType){ diff --git a/gnss/GnssAdapter.h b/gnss/GnssAdapter.h index c1e17545..8d639fe8 100644 --- a/gnss/GnssAdapter.h +++ b/gnss/GnssAdapter.h @@ -157,7 +157,7 @@ public: LocationCallbacks getClientCallbacks(LocationAPI* client); LocationCapabilitiesMask getCapabilities(); void broadcastCapabilities(LocationCapabilitiesMask); - LocationError setSuplHostServer(const char* server, int port); + void setSuplHostServer(const char* server, int port); /* ==== TRACKING ======================================================================= */ /* ======== COMMANDS ====(Called from Client Thread)==================================== */ @@ -180,12 +180,16 @@ public: void eraseTrackingSession(LocationAPI* client, uint32_t sessionId); bool setUlpPositionMode(const LocPosMode& mode); LocPosMode& getUlpPositionMode() { return mUlpPositionMode; } - LocationError startTrackingMultiplex(const LocationOptions& options); - LocationError startTracking(const LocationOptions& options); - LocationError stopTrackingMultiplex(LocationAPI* client, uint32_t id); - LocationError stopTracking(); - LocationError updateTrackingMultiplex(LocationAPI* client, uint32_t id, + bool startTrackingMultiplex(LocationAPI* client, uint32_t sessionId, + const LocationOptions& options); + bool startTracking(LocationAPI* client, uint32_t sessionId, + const LocationOptions& options); + bool stopTrackingMultiplex(LocationAPI* client, uint32_t id); + bool stopTracking(LocationAPI* client, uint32_t id); + bool updateTrackingMultiplex(LocationAPI* client, uint32_t id, const LocationOptions& options); + bool updateTracking(LocationAPI* client, uint32_t sessionId, + const LocationOptions& updatedOptions, const LocationOptions& oldOptions); /* ==== NI ============================================================================= */ /* ======== COMMANDS ====(Called from Client Thread)==================================== */ @@ -203,9 +207,11 @@ public: void setControlCallbacksCommand(LocationControlCallbacks& controlCallbacks); void readConfigCommand(); void setConfigCommand(); + void requestUlpCommand(); void initEngHubProxyCommand(); uint32_t* gnssUpdateConfigCommand(GnssConfig config); uint32_t gnssDeleteAidingDataCommand(GnssAidingData& data); + void deleteAidingData(const GnssAidingData &data, uint32_t sessionId); void gnssUpdateXtraThrottleCommand(const bool enabled); void initDefaultAgpsCommand(); @@ -224,7 +230,6 @@ public: { mControlCallbacks = controlCallbacks; } void setPowerVoteId(uint32_t id) { mPowerVoteId = id; } uint32_t getPowerVoteId() { return mPowerVoteId; } - bool resolveInAddress(const char* hostAddress, struct in_addr* inAddress); virtual bool isInSession() { return !mTrackingSessions.empty(); } void initDefaultAgps(); bool initEngHubProxy(); @@ -249,6 +254,8 @@ public: virtual bool requestSuplES(int connHandle); virtual bool reportDataCallOpened(); virtual bool reportDataCallClosed(); + virtual bool reportZppBestAvailableFix(LocGpsLocation &zppLoc, + GpsLocationExtended &location_extended, LocPosTechMask tech_mask); /* ======== UTILITIES ================================================================= */ bool needReport(const UlpLocation& ulpLocation, @@ -276,15 +283,11 @@ public: static uint32_t convertGpsLock(const GnssConfigGpsLock gpsLock); static GnssConfigGpsLock convertGpsLock(const uint32_t gpsLock); static uint32_t convertSuplVersion(const GnssConfigSuplVersion suplVersion); - static GnssConfigSuplVersion convertSuplVersion(const uint32_t suplVersion); static uint32_t convertLppProfile(const GnssConfigLppProfile lppProfile); - static GnssConfigLppProfile convertLppProfile(const uint32_t lppProfile); static uint32_t convertEP4ES(const GnssConfigEmergencyPdnForEmergencySupl); static uint32_t convertSuplEs(const GnssConfigSuplEmergencyServices suplEmergencyServices); static uint32_t convertLppeCp(const GnssConfigLppeControlPlaneMask lppeControlPlaneMask); - static GnssConfigLppeControlPlaneMask convertLppeCp(const uint32_t lppeControlPlaneMask); static uint32_t convertLppeUp(const GnssConfigLppeUserPlaneMask lppeUserPlaneMask); - static GnssConfigLppeUserPlaneMask convertLppeUp(const uint32_t lppeUserPlaneMask); static uint32_t convertAGloProt(const GnssConfigAGlonassPositionProtocolMask); static uint32_t convertSuplMode(const GnssConfigSuplModeMask suplModeMask); static void convertSatelliteInfo(std::vector& out, diff --git a/gnss/Makefile.am b/gnss/Makefile.am index 7ee60892..db20c15a 100644 --- a/gnss/Makefile.am +++ b/gnss/Makefile.am @@ -7,7 +7,7 @@ AM_CFLAGS = \ -I../utils \ -I$(WORKSPACE)/hardware/qcom/gps/core/data-items \ -I../location \ - -std=c++11 + -std=c++1y libgnss_la_SOURCES = \ location_gnss.cpp \ From 4c8f4e4e0437aff2694d9550579ee038c9209c5d Mon Sep 17 00:00:00 2001 From: Bhavna Sharma Date: Fri, 30 Mar 2018 17:10:59 -0700 Subject: [PATCH 03/14] GPS Adapter: GNSS adapter change to go with engine hub aggregator 1: GNSS adapter change to block out position and SV report from ULP when engine hub aggregator is used 2: Support unpropagated position report Change-Id: Id0cacd87d3f3f8eec893d751b9f7a55a736a4023 CRs-fixed: 2210253 --- core/EngineHubProxyBase.h | 7 +++-- core/LocAdapterBase.cpp | 5 ++-- core/LocAdapterBase.h | 6 +++-- gnss/GnssAdapter.cpp | 54 +++++++++++++++++++++++++++++++-------- gnss/GnssAdapter.h | 7 +++-- utils/gps_extended_c.h | 4 ++- 6 files changed, 64 insertions(+), 19 deletions(-) diff --git a/core/EngineHubProxyBase.h b/core/EngineHubProxyBase.h index 7b9f3ae8..4e259ba7 100644 --- a/core/EngineHubProxyBase.h +++ b/core/EngineHubProxyBase.h @@ -92,10 +92,13 @@ typedef std::function + bool fromUlp, + bool fromEngineHub)> GnssAdapterReportPositionEventCb; -typedef std::function +typedef std::function GnssAdapterReportSvEventCb; // potential parameters: message queue: MsgTask * msgTask; diff --git a/core/LocAdapterBase.cpp b/core/LocAdapterBase.cpp index f3c999c2..5d1b2c21 100644 --- a/core/LocAdapterBase.cpp +++ b/core/LocAdapterBase.cpp @@ -79,7 +79,7 @@ void LocAdapterBase:: const GpsLocationExtended& locationExtended, enum loc_sess_status status, LocPosTechMask loc_technology_mask, - bool /*fromUlp*/) { + bool /*fromUlp*/, bool /*fromEngineHub*/) { if (mLocAdapterProxyBase != NULL) { mLocAdapterProxyBase->reportPositionEvent((UlpLocation&)location, (GpsLocationExtended&)locationExtended, @@ -91,7 +91,8 @@ void LocAdapterBase:: } void LocAdapterBase:: - reportSvEvent(const GnssSvNotification& /*svNotify*/, bool /*fromUlp*/) + reportSvEvent(const GnssSvNotification& /*svNotify*/, + bool /*fromUlp*/, bool /*fromEngineHub*/) DEFAULT_IMPL() void LocAdapterBase:: diff --git a/core/LocAdapterBase.h b/core/LocAdapterBase.h index e7beca83..8388c712 100644 --- a/core/LocAdapterBase.h +++ b/core/LocAdapterBase.h @@ -131,8 +131,10 @@ public: const GpsLocationExtended& locationExtended, enum loc_sess_status status, LocPosTechMask loc_technology_mask, - bool fromUlp=false); - virtual void reportSvEvent(const GnssSvNotification& svNotify, bool fromUlp=false); + bool fromUlp=false, + bool fromEngineHub=false); + virtual void reportSvEvent(const GnssSvNotification& svNotify, + bool fromUlp=false, bool fromEngineHub=false); virtual void reportNmeaEvent(const char* nmea, size_t length, bool fromUlp=false); virtual void reportSvMeasurementEvent(GnssSvMeasurementSet &svMeasurementSet); virtual void reportSvPolynomialEvent(GnssSvPolynomial &svPolynomial); diff --git a/gnss/GnssAdapter.cpp b/gnss/GnssAdapter.cpp index f996ebee..ff352e20 100644 --- a/gnss/GnssAdapter.cpp +++ b/gnss/GnssAdapter.cpp @@ -1230,6 +1230,7 @@ GnssAdapter::updateClientsEventMask() (true == initEngHubProxy())) { mask |= LOC_API_ADAPTER_BIT_GNSS_MEASUREMENT; mask |= LOC_API_ADAPTER_BIT_GNSS_SV_POLYNOMIAL_REPORT; + mask |= LOC_API_ADAPTER_BIT_PARSED_UNPROPAGATED_POSITION_REPORT; LOC_LOGD("%s]: Auto usecase, Enable MEAS/POLY - mask 0x%x", __func__, mask); } @@ -2092,22 +2093,43 @@ GnssAdapter::reportPositionEvent(const UlpLocation& ulpLocation, const GpsLocationExtended& locationExtended, enum loc_sess_status status, LocPosTechMask techMask, - bool fromUlp) + bool fromUlp, + bool fromEngineHub) { LOC_LOGD("%s]: fromUlp %u status %u", __func__, fromUlp, status); // if this event is called from QMI LOC API, then try to call into ULP and return if successfull // if the position is called from ULP or engine hub, then send it out directly - if (!fromUlp) { - // report QMI position to engine hub, and engine hub will be - // distributing it to the registered plugins + if (!fromUlp && !fromEngineHub) { + // report QMI position (both propagated and unpropagated) to engine hub, + // and engine hub will be distributing it to the registered plugins mEngHubProxy->gnssReportPosition(ulpLocation, locationExtended, status); + + if (true == ulpLocation.unpropagatedPosition) { + return; + } + + // only send propagated position report to ulp if (mUlpProxy->reportPosition(ulpLocation, locationExtended, status, techMask)) { return; } + + // engine hub is loaded, do not report qmi position to client as + // final position report should come from engine hub + if (true == initEngHubProxy()){ + return; + } + } else if ((true == fromUlp) && (true == initEngHubProxy())) { + LOC_LOGV("%s]: drop ULP GNSS fix as engine hub is loaded", __func__); + return; } + // for all other cases: + // case 1: fix is from ULP and engine hub is not loaded, queue the msg + // case 2: fix is from engine hub, queue the msg + // when message is queued, the position can be dispatched to requesting client + struct MsgReportPosition : public LocMsg { GnssAdapter& mAdapter; const UlpLocation mUlpLocation; @@ -2208,18 +2230,28 @@ GnssAdapter::reportPosition(const UlpLocation& ulpLocation, void GnssAdapter::reportSvEvent(const GnssSvNotification& svNotify, - bool fromUlp) + bool fromUlp, + bool fromEngineHub) { LOC_LOGD("%s]: fromUlp %u", __func__, fromUlp); // if this event is not called from ULP, then try to call into ULP and return if successfull - if (!fromUlp) { + if (!fromUlp && !fromEngineHub) { // report QMI SV report to eng hub mEngHubProxy->gnssReportSv(svNotify); if (mUlpProxy->reportSv(svNotify)) { return; } + + // engine hub is loaded, do not report sv to client + // as sv report should come from engine hub + if (true == initEngHubProxy()){ + return; + } + } else if ((true == fromUlp) && (true == initEngHubProxy())) { + LOC_LOGV("%s]: drop ULP GNSS SV event as engine hub is loaded", __func__); + return; } struct MsgReportSv : public LocMsg { @@ -3297,15 +3329,17 @@ GnssAdapter::initEngHubProxy() { const GpsLocationExtended& locationExtended, enum loc_sess_status status, LocPosTechMask techMask, - bool fromUlp) { + bool fromUlp, + bool fromEngineHub) { // report from engine hub on behalf of PPE will be treated as fromUlp - reportPositionEvent(ulpLocation, locationExtended, status, techMask, fromUlp); + reportPositionEvent(ulpLocation, locationExtended, status, + techMask, fromUlp, fromEngineHub); }; // callback function for engine hub to report back sv event GnssAdapterReportSvEventCb reportSvEventCb = - [this](const GnssSvNotification& svNotify, bool fromUlp) { - reportSvEvent(svNotify, fromUlp); + [this](const GnssSvNotification& svNotify, bool fromUlp, bool fromEngineHub) { + reportSvEvent(svNotify, fromUlp, fromEngineHub); }; getEngHubProxyFn* getter = (getEngHubProxyFn*) dlsym(handle, "getEngHubProxy"); diff --git a/gnss/GnssAdapter.h b/gnss/GnssAdapter.h index c1e17545..85962cfb 100644 --- a/gnss/GnssAdapter.h +++ b/gnss/GnssAdapter.h @@ -235,8 +235,11 @@ public: const GpsLocationExtended& locationExtended, enum loc_sess_status status, LocPosTechMask techMask, - bool fromUlp=false); - virtual void reportSvEvent(const GnssSvNotification& svNotify, bool fromUlp=false); + bool fromUlp=false, + bool fromEngineHub=false); + virtual void reportSvEvent(const GnssSvNotification& svNotify, + bool fromUlp=false, + bool fromEngineHub=false); virtual void reportNmeaEvent(const char* nmea, size_t length, bool fromUlp=false); virtual bool requestNiNotifyEvent(const GnssNiNotification& notify, const void* data); virtual void reportGnssMeasurementDataEvent(const GnssMeasurementsNotification& measurements, diff --git a/utils/gps_extended_c.h b/utils/gps_extended_c.h index bd528d9e..29b658fe 100644 --- a/utils/gps_extended_c.h +++ b/utils/gps_extended_c.h @@ -127,6 +127,7 @@ typedef struct { /* Provider indicator for HYBRID or GPS */ uint16_t position_source; LocPosTechMask tech_mask; + bool unpropagatedPosition; } UlpLocation; typedef struct { @@ -583,6 +584,7 @@ enum loc_api_adapter_event_index { LOC_API_ADAPTER_REQUEST_POSITION_INJECTION, // Position injection request LOC_API_ADAPTER_BATCH_STATUS, // batch status LOC_API_ADAPTER_FDCL_SERVICE_REQ, // FDCL service request + LOC_API_ADAPTER_REPORT_UNPROPAGATED_POSITION, // Unpropagated Position report LOC_API_ADAPTER_EVENT_MAX }; @@ -619,7 +621,7 @@ enum loc_api_adapter_event_index { #define LOC_API_ADAPTER_BIT_POSITION_INJECTION_REQUEST (1< Date: Tue, 17 Apr 2018 11:11:26 -0700 Subject: [PATCH 04/14] fix: Incorrect path to ehub socket directory Change-Id: I58b41c4a8de8b51c8a6effe989182ea5942cff6e CRs-Fixed: 2196048 --- utils/gps_extended_c.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/utils/gps_extended_c.h b/utils/gps_extended_c.h index b7b1c09c..21eb5d55 100644 --- a/utils/gps_extended_c.h +++ b/utils/gps_extended_c.h @@ -1495,7 +1495,7 @@ typedef void (*LocAgpsCloseResultCb)(bool isSuccess, AGpsExtType agpsType, void* #define LOC_IPC_XTRA "/dev/socket/location/xtra/socket_xtra" #define SOCKET_DIR_LOCATION "/dev/socket/location/" -#define SOCKET_DIR_EHUB "/dev/socket/location/ehub" +#define SOCKET_DIR_EHUB "/dev/socket/location/ehub/" #define SOCKET_TO_LOCATION_HAL_DAEMON "/dev/socket/location/hal_daemon" #define SOCKET_DIR_TO_CLIENT "/dev/socket/loc_client/" From 4005daa98993fe4325ecef5335ec86a09cd49665 Mon Sep 17 00:00:00 2001 From: Katz Yamada Date: Fri, 23 Mar 2018 10:32:51 -0700 Subject: [PATCH 05/14] fix: LocIpc client app unable to exit LocIpc client apps such as garden app is unable to delete LocIpc object since its socket listening thread cannot be closed while it is waiting for data and cannot be closed. Fixed to close it by sending an abort message. CRs-Fixed: 2213212 Change-Id: I95f26862e9faf7bd75a2f447421ba4ab7220576e --- utils/LocIpc.cpp | 38 ++++++++++++++++++++++++-------------- utils/LocIpc.h | 3 +-- 2 files changed, 25 insertions(+), 16 deletions(-) diff --git a/utils/LocIpc.cpp b/utils/LocIpc.cpp index 26a20765..59b659e4 100644 --- a/utils/LocIpc.cpp +++ b/utils/LocIpc.cpp @@ -28,19 +28,8 @@ */ #include -#include -#include #include -#include -#include -#include -#include -#include -#include #include -#include -#include -#include "gps_extended_c.h" #include "LocIpc.h" namespace loc_util { @@ -52,8 +41,10 @@ namespace loc_util { #define LOC_MSG_BUF_LEN 8192 #define LOC_MSG_HEAD "$MSGLEN$" +#define LOC_MSG_ABORT "LocIpcMsg::ABORT" class LocIpcRunnable : public LocRunnable { +friend LocIpc; public: LocIpcRunnable(LocIpc& locIpc, const std::string& ipcName) : mLocIpc(locIpc), mIpcName(ipcName) {} @@ -70,10 +61,10 @@ private: }; bool LocIpc::startListeningNonBlocking(const std::string& name) { - mRunnable.reset(new LocIpcRunnable(*this, name)); + mRunnable = new LocIpcRunnable(*this, name); std::string threadName("LocIpc-"); threadName.append(name); - return mThread.start(threadName.c_str(), mRunnable.get()); + return mThread.start(threadName.c_str(), mRunnable); } bool LocIpc::startListeningBlocking(const std::string& name) { @@ -107,6 +98,7 @@ bool LocIpc::startListeningBlocking(const std::string& name) { ssize_t nBytes = 0; std::string msg = ""; + std::string abort = LOC_MSG_ABORT; while (1) { msg.resize(LOC_MSG_BUF_LEN); nBytes = ::recvfrom(mIpcFd, (void*)(msg.data()), msg.size(), 0, NULL, NULL); @@ -116,6 +108,11 @@ bool LocIpc::startListeningBlocking(const std::string& name) { continue; } + if (strncmp(msg.data(), abort.c_str(), abort.length()) == 0) { + LOC_LOGi("recvd abort msg.data %s", msg.data()); + break; + } + if (strncmp(msg.data(), LOC_MSG_HEAD, sizeof(LOC_MSG_HEAD) - 1)) { // short message msg.resize(nBytes); @@ -142,7 +139,6 @@ bool LocIpc::startListeningBlocking(const std::string& name) { if (mStopRequested) { mStopRequested = false; return true; - } else { LOC_LOGe("cannot read socket. reason:%s", strerror(errno)); (void)::close(mIpcFd); @@ -152,14 +148,28 @@ bool LocIpc::startListeningBlocking(const std::string& name) { } void LocIpc::stopListening() { + + const char *socketName = nullptr; mStopRequested = true; + if (mRunnable) { + std::string abort = LOC_MSG_ABORT; + socketName = (reinterpret_cast(mRunnable))->mIpcName.c_str(); + send(socketName, abort); + mRunnable = nullptr; + } + if (mIpcFd >= 0) { if (::close(mIpcFd)) { LOC_LOGe("cannot close socket:%s", strerror(errno)); } mIpcFd = -1; } + + //delete from the file system at the end + if (socketName) { + unlink(socketName); + } } bool LocIpc::send(const char name[], const std::string& data) { diff --git a/utils/LocIpc.h b/utils/LocIpc.h index 0c37a7ad..a1a994d1 100644 --- a/utils/LocIpc.h +++ b/utils/LocIpc.h @@ -32,7 +32,6 @@ #include #include -#include #include #include #include @@ -96,7 +95,7 @@ private: int mIpcFd; bool mStopRequested; LocThread mThread; - std::unique_ptr mRunnable; + LocRunnable *mRunnable; }; class LocIpcSender { From 9a8c42c3cb5beebe6e5259cccc12b4b6de1c4010 Mon Sep 17 00:00:00 2001 From: Katz Yamada Date: Tue, 3 Apr 2018 16:37:47 -0700 Subject: [PATCH 06/14] fix: Creating LocationAPI object rejected LocationAPI::createInstance() to accept if any one of gnssNiCb, trackingCb, gnssLocationCb or gnssMeasurementsCb is set. Change-Id: I3d026cd608aca2b9e0ee93617e10dc0b32e37849 CRs-Fixed: 2218707 --- location/LocationAPI.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/location/LocationAPI.cpp b/location/LocationAPI.cpp index 0111a9c0..e43d9e03 100644 --- a/location/LocationAPI.cpp +++ b/location/LocationAPI.cpp @@ -62,6 +62,7 @@ static bool isGnssClient(LocationCallbacks& locationCallbacks) { return (locationCallbacks.gnssNiCb != nullptr || locationCallbacks.trackingCb != nullptr || + locationCallbacks.gnssLocationInfoCb != nullptr || locationCallbacks.gnssMeasurementsCb != nullptr); } From 21308b61a8cacd8b3a9129f4431796aa78934b06 Mon Sep 17 00:00:00 2001 From: Bhavna Sharma Date: Fri, 27 Apr 2018 13:38:36 -0700 Subject: [PATCH 07/14] GNSS adapter: Do not send SPE NMEA to engine hub Engine service does not need SPE NMEA report. Change-Id: I809fa2857eec8292269b640928a44d8cc54308ed CRs-fixed: 2232811 --- core/EngineHubProxyBase.h | 5 ----- gnss/GnssAdapter.cpp | 4 ++-- 2 files changed, 2 insertions(+), 7 deletions(-) diff --git a/core/EngineHubProxyBase.h b/core/EngineHubProxyBase.h index 4e259ba7..5282350f 100644 --- a/core/EngineHubProxyBase.h +++ b/core/EngineHubProxyBase.h @@ -81,11 +81,6 @@ public: (void) svPolynomial; return false; } - - inline virtual bool gnssReportNmea(const char* nmea) { - (void) nmea; - return false; - } }; typedef std::functiongnssReportNmea(nmea); if (mUlpProxy->reportNmea(nmea, length)) { return; } From a6177a4d144db112aa9e9afd963ca476a5630285 Mon Sep 17 00:00:00 2001 From: Naresh Munagala Date: Mon, 30 Apr 2018 12:22:18 +0530 Subject: [PATCH 08/14] Changed max size of line read of config. Change-Id: Ib1c7b11b03cdb8d788148091135313b438723670 CRs-Fixed: 2233260 --- utils/loc_cfg.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/utils/loc_cfg.h b/utils/loc_cfg.h index c89d3038..e0e711ed 100644 --- a/utils/loc_cfg.h +++ b/utils/loc_cfg.h @@ -37,7 +37,7 @@ #include #define LOC_MAX_PARAM_NAME 80 -#define LOC_MAX_PARAM_STRING 80 +#define LOC_MAX_PARAM_STRING 170 #define LOC_MAX_PARAM_LINE (LOC_MAX_PARAM_NAME + LOC_MAX_PARAM_STRING) #define LOC_FEATURE_MODE_DISABLED "DISABLED" From 6c80f04dbace74cc65bdd5eb85239790b1711bf6 Mon Sep 17 00:00:00 2001 From: Bhavna Sharma Date: Fri, 25 May 2018 14:34:08 -0700 Subject: [PATCH 09/14] Populate some more fields for end client. These are the fields populated: North, East, Up velocity and their uncertainties North and East standard deviation Gps Time, Leap Sec and time uncertainty Gps Measurement usage info CRs-Fixed: 2249350 Change-Id: I8936b1c47be25fdc792322592f8ea5466a3fa6fd --- gnss/GnssAdapter.cpp | 55 ++++++++++++++++++++++++++ location/LocationDataTypes.h | 75 ++++++++++++++++++++++++++++++++++-- utils/gps_extended_c.h | 19 ++++++--- 3 files changed, 140 insertions(+), 9 deletions(-) diff --git a/gnss/GnssAdapter.cpp b/gnss/GnssAdapter.cpp index 3f9d3cf8..ef835aee 100644 --- a/gnss/GnssAdapter.cpp +++ b/gnss/GnssAdapter.cpp @@ -320,6 +320,38 @@ GnssAdapter::convertLocationInfo(GnssLocationInfoNotification& out, out.flags |= GNSS_LOCATION_INFO_HOR_ACCURACY_ELIP_AZIMUTH_BIT; out.horUncEllipseOrientAzimuth = locationExtended.horUncEllipseOrientAzimuth; } + if (GPS_LOCATION_EXTENDED_HAS_NORTH_STD_DEV & locationExtended.flags) { + out.flags |= GNSS_LOCATION_INFO_NORTH_STD_DEV_BIT; + out.northVelocityStdDeviation = locationExtended.northStdDeviation; + } + if (GPS_LOCATION_EXTENDED_HAS_EAST_STD_DEV & locationExtended.flags) { + out.flags |= GNSS_LOCATION_INFO_EAST_STD_DEV_BIT; + out.eastVelocityStdDeviation = locationExtended.eastStdDeviation; + } + if (GPS_LOCATION_EXTENDED_HAS_NORTH_VEL & locationExtended.flags) { + out.flags |= GNSS_LOCATION_INFO_NORTH_VEL_BIT; + out.northVelocity = locationExtended.northVelocity; + } + if (GPS_LOCATION_EXTENDED_HAS_NORTH_VEL_UNC & locationExtended.flags) { + out.flags |= GNSS_LOCATION_INFO_NORTH_VEL_UNC_BIT; + out.northVelocityStdDeviation = locationExtended.northVelocityStdDeviation; + } + if (GPS_LOCATION_EXTENDED_HAS_EAST_VEL & locationExtended.flags) { + out.flags |= GNSS_LOCATION_INFO_EAST_VEL_BIT; + out.eastVelocity = locationExtended.eastVelocity; + } + if (GPS_LOCATION_EXTENDED_HAS_EAST_VEL_UNC & locationExtended.flags) { + out.flags |= GNSS_LOCATION_INFO_EAST_VEL_UNC_BIT; + out.eastVelocityStdDeviation = locationExtended.eastVelocityStdDeviation; + } + if (GPS_LOCATION_EXTENDED_HAS_UP_VEL & locationExtended.flags) { + out.flags |= GNSS_LOCATION_INFO_UP_VEL_BIT; + out.upVelocity = locationExtended.upVelocity; + } + if (GPS_LOCATION_EXTENDED_HAS_UP_VEL_UNC & locationExtended.flags) { + out.flags |= GNSS_LOCATION_INFO_UP_VEL_UNC_BIT; + out.upVelocityStdDeviation = locationExtended.upVelocityStdDeviation; + } if (GPS_LOCATION_EXTENDED_HAS_GNSS_SV_USED_DATA & locationExtended.flags) { out.flags |= GNSS_LOCATION_INFO_GNSS_SV_USED_DATA_BIT; out.svUsedInPosition.gpsSvUsedIdsMask = @@ -332,6 +364,16 @@ GnssAdapter::convertLocationInfo(GnssLocationInfoNotification& out, locationExtended.gnss_sv_used_ids.bds_sv_used_ids_mask; out.svUsedInPosition.qzssSvUsedIdsMask = locationExtended.gnss_sv_used_ids.qzss_sv_used_ids_mask; + out.numOfMeasReceived = locationExtended.numOfMeasReceived; + + for (int idx =0; idx < locationExtended.numOfMeasReceived; idx++) { + out.measUsageInfo[idx].gnssSignalType = + locationExtended.measUsageInfo[idx].gnssSignalType; + out.measUsageInfo[idx].gnssSvId = + locationExtended.measUsageInfo[idx].gnssSvId; + out.measUsageInfo[idx].gnssConstellation = + locationExtended.measUsageInfo[idx].gnssConstellation; + } } if (GPS_LOCATION_EXTENDED_HAS_NAV_SOLUTION_MASK & locationExtended.flags) { out.flags |= GNSS_LOCATION_INFO_NAV_SOLUTION_MASK_BIT; @@ -367,6 +409,19 @@ GnssAdapter::convertLocationInfo(GnssLocationInfoNotification& out, out.bodyFrameData.yawRate = locationExtended.bodyFrameData.yawRate; out.bodyFrameData.pitch = locationExtended.bodyFrameData.pitch; } + + // Validity of this structure is established from the timeSrc of the GnssSystemTime structure. + out.gnssSystemTime = locationExtended.gnssSystemTime; + + if (GPS_LOCATION_EXTENDED_HAS_LEAP_SECONDS & locationExtended.flags) { + out.flags |= GNSS_LOCATION_INFO_LEAP_SECONDS_BIT; + out.leapSeconds = locationExtended.leapSeconds; + } + + if (GPS_LOCATION_EXTENDED_HAS_TIME_UNC & locationExtended.flags) { + out.flags |= GNSS_LOCATION_INFO_TIME_UNC_BIT; + out.timeUncMs = locationExtended.timeUncMs; + } } inline uint32_t diff --git a/location/LocationDataTypes.h b/location/LocationDataTypes.h index 00cca183..8bb11cc7 100644 --- a/location/LocationDataTypes.h +++ b/location/LocationDataTypes.h @@ -137,8 +137,17 @@ typedef enum { GNSS_LOCATION_INFO_POS_TECH_MASK_BIT = (1<<10),// valid LocPosTechMask GNSS_LOCATION_INFO_SV_SOURCE_INFO_BIT = (1<<11),// valid LocSvInfoSource GNSS_LOCATION_INFO_POS_DYNAMICS_DATA_BIT = (1<<12),// valid position dynamics data - GNSS_LOCATION_INFO_GPS_TIME_BIT = (1<<13),// valid GPS Time - GNSS_LOCATION_INFO_EXT_DOP_BIT = (1<<14) // valid gdop, tdop + GNSS_LOCATION_INFO_EXT_DOP_BIT = (1<<13),// valid gdop, tdop + GNSS_LOCATION_INFO_NORTH_STD_DEV_BIT = (1<<14),// valid North standard deviation + GNSS_LOCATION_INFO_EAST_STD_DEV_BIT = (1<<15),// valid East standard deviation + GNSS_LOCATION_INFO_NORTH_VEL_BIT = (1<<16),// valid North Velocity + GNSS_LOCATION_INFO_EAST_VEL_BIT = (1<<17),// valid East Velocity + GNSS_LOCATION_INFO_UP_VEL_BIT = (1<<18),// valid Up Velocity + GNSS_LOCATION_INFO_NORTH_VEL_UNC_BIT = (1<<19),// valid North Velocity Uncertainty + GNSS_LOCATION_INFO_EAST_VEL_UNC_BIT = (1<<20),// valid East Velocity Uncertainty + GNSS_LOCATION_INFO_UP_VEL_UNC_BIT = (1<<21),// valid Up Velocity Uncertainty + GNSS_LOCATION_INFO_LEAP_SECONDS_BIT = (1<<22),// valid leap seconds + GNSS_LOCATION_INFO_TIME_UNC_BIT = (1<<23) // valid time uncertainty } GnssLocationInfoFlagBits; typedef enum { @@ -452,6 +461,43 @@ typedef enum { GNSS_AIDING_DATA_SV_TYPE_GALILEO_BIT = (1<<4), } GnssAidingDataSvTypeBits; +/** GNSS Signal Type and RF Band */ +typedef uint32_t GnssSignalTypeMask; +typedef enum { + /** GPS L1CA Signal */ + GNSS_SIGNAL_GPS_L1CA = (1<<0), + /** GPS L1C Signal */ + GNSS_SIGNAL_GPS_L1C = (1<<1), + /** GPS L2 RF Band */ + GNSS_SIGNAL_GPS_L2 = (1<<2), + /** GPS L5 RF Band */ + GNSS_SIGNAL_GPS_L5 = (1<<3), + /** GLONASS G1 (L1OF) RF Band */ + GNSS_SIGNAL_GLONASS_G1 = (1<<4), + /** GLONASS G2 (L2OF) RF Band */ + GNSS_SIGNAL_GLONASS_G2 = (1<<5), + /** GALILEO E1 RF Band */ + GNSS_SIGNAL_GALILEO_E1 = (1<<6), + /** GALILEO E5A RF Band */ + GNSS_SIGNAL_GALILEO_E5A = (1<<7), + /** GALILEO E5B RF Band */ + GNSS_SIGNAL_GALILIEO_E5B = (1<<8), + /** BEIDOU B1 RF Band */ + GNSS_SIGNAL_BEIDOU_B1 = (1<<9), + /** BEIDOU B2 RF Band */ + GNSS_SIGNAL_BEIDOU_B2 = (1<<10), + /** QZSS L1CA RF Band */ + GNSS_SIGNAL_QZSS_L1CA = (1<<11), + /** QZSS L1S RF Band */ + GNSS_SIGNAL_QZSS_L1S = (1<<12), + /** QZSS L2 RF Band */ + GNSS_SIGNAL_QZSS_L2 = (1<<13), + /** QZSS L5 RF Band */ + GNSS_SIGNAL_QZSS_L5 = (1<<14), + /** SBAS L1 RF Band */ + GNSS_SIGNAL_SBAS_L1 = (1<<15) +} GnssSignalTypeBits; + typedef enum { GNSS_LOC_SV_SYSTEM_GPS = 1, @@ -587,6 +633,21 @@ typedef struct { uint64_t qzssSvUsedIdsMask; } GnssLocationSvUsedInPosition; +typedef struct { + /** GnssSignalType mask */ + GnssSignalTypeMask gnssSignalType; + /** Specifies GNSS Constellation Type */ + Gnss_LocSvSystemEnumType gnssConstellation; + /** GNSS SV ID. + For GPS: 1 to 32 + For GLONASS: 65 to 96. When slot-number to SV ID mapping is unknown, set as 255. + For SBAS: 120 to 151 + For QZSS-L1CA:193 to 197 + For BDS: 201 to 237 + For GAL: 301 to 336 */ + uint16_t gnssSvId; +} GnssMeasUsageInfo; + /** @struct Body Frame parameters */ @@ -702,9 +763,11 @@ typedef struct { float horUncEllipseSemiMajor; // horizontal elliptical accuracy semi-major axis float horUncEllipseSemiMinor; // horizontal elliptical accuracy semi-minor axis float horUncEllipseOrientAzimuth; // horizontal elliptical accuracy azimuth + float northStdDeviation; // North standard deviation Unit: Meters + float eastStdDeviation; // East standard deviation. Unit: Meters float northVelocity; // North Velocity.Unit: Meters/sec - float eastVelocity; // East Velocity - float upVelocity; + float eastVelocity; // East Velocity Unit Meters/sec + float upVelocity; // Up Velocity. Unit Meters/sec float northVelocityStdDeviation; float eastVelocityStdDeviation; float upVelocityStdDeviation; @@ -714,6 +777,10 @@ typedef struct { GnssLocationPositionDynamics bodyFrameData; // Body Frame Dynamics: 4wayAcceleration and // pitch set with validity GnssSystemTime gnssSystemTime; // GNSS System Time + uint8_t numOfMeasReceived; // Number of measurements received for use in fix. + GnssMeasUsageInfo measUsageInfo[GNSS_SV_MAX]; // GNSS Measurement Usage info + uint8_t leapSeconds; // leap second + float timeUncMs; // Time uncertainty in milliseconds Location location; } GnssLocationInfoNotification; diff --git a/utils/gps_extended_c.h b/utils/gps_extended_c.h index 21eb5d55..ea38eb38 100644 --- a/utils/gps_extended_c.h +++ b/utils/gps_extended_c.h @@ -268,7 +268,7 @@ typedef enum loc_position_mode_type { #define GPS_DEFAULT_FIX_INTERVAL_MS 1000 /** Flags to indicate which values are valid in a GpsLocationExtended. */ -typedef uint32_t GpsLocationExtendedFlags; +typedef uint64_t GpsLocationExtendedFlags; /** GpsLocationExtended has valid pdop, hdop, vdop. */ #define GPS_LOCATION_EXTENDED_HAS_DOP 0x0001 /** GpsLocationExtended has valid altitude mean sea level. */ @@ -323,14 +323,19 @@ typedef uint32_t GpsLocationExtendedFlags; #define GPS_LOCATION_EXTENDED_HAS_EAST_VEL_UNC 0x2000000 /** GpsLocationExtended has up Velocity Uncertainty */ #define GPS_LOCATION_EXTENDED_HAS_UP_VEL_UNC 0x4000000 -/** GpsLocationExtended has up Clock Bias */ +/** GpsLocationExtended has Clock Bias */ #define GPS_LOCATION_EXTENDED_HAS_CLOCK_BIAS 0x8000000 -/** GpsLocationExtended has up Clock Bias std deviation*/ +/** GpsLocationExtended has Clock Bias std deviation*/ #define GPS_LOCATION_EXTENDED_HAS_CLOCK_BIAS_STD_DEV 0x10000000 -/** GpsLocationExtended has up Clock drift*/ +/** GpsLocationExtended has Clock drift*/ #define GPS_LOCATION_EXTENDED_HAS_CLOCK_DRIFT 0x20000000 -/** GpsLocationExtended has up Clock drift std deviation**/ +/** GpsLocationExtended has Clock drift std deviation**/ #define GPS_LOCATION_EXTENDED_HAS_CLOCK_DRIFT_STD_DEV 0x40000000 +/** GpsLocationExtended has leap seconds **/ +#define GPS_LOCATION_EXTENDED_HAS_LEAP_SECONDS 0x80000000 +/** GpsLocationExtended has time uncertainty **/ +#define GPS_LOCATION_EXTENDED_HAS_TIME_UNC 0x100000000 + typedef uint32_t LocNavSolutionMask; /* Bitmask to specify whether SBAS ionospheric correction is used */ @@ -660,6 +665,10 @@ typedef struct { uint8_t numOfMeasReceived; /** Measurement Usage Information */ GpsMeasUsageInfo measUsageInfo[GNSS_SV_MAX]; + /** Leap Seconds */ + uint8_t leapSeconds; + /** Time uncertainty in milliseconds */ + float timeUncMs; } GpsLocationExtended; enum loc_sess_status { From aac86a158ad76119efe8d9b0718f600354a99b97 Mon Sep 17 00:00:00 2001 From: Bhavna Sharma Date: Mon, 18 Jun 2018 16:51:41 +0530 Subject: [PATCH 10/14] body frame uncertainty parameters in position report added uncertainty parameters for longAccel, latAccel, vertAccel, yawRate and pitch. Change-Id: I804dc0b370dd78402a6641f5a16e5ee7a53ff9a1 CRs-Fixed: 2262454 --- utils/gps_extended_c.h | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/utils/gps_extended_c.h b/utils/gps_extended_c.h index 21eb5d55..255acd8e 100644 --- a/utils/gps_extended_c.h +++ b/utils/gps_extended_c.h @@ -359,6 +359,16 @@ typedef uint32_t LocPosDataMask; #define LOC_NAV_DATA_HAS_YAW_RATE ((LocPosDataMask)0x0008) /* Bitmask to specify whether Navigation data has Body pitch */ #define LOC_NAV_DATA_HAS_PITCH ((LocPosDataMask)0x0010) +/* Bitmask to specify whether Navigation data has Forward Acceleration Unc */ +#define LOC_NAV_DATA_HAS_LONG_ACCEL_UNC ((LocPosDataMask)0x0020) +/* Bitmask to specify whether Navigation data has Sideward Acceleration Unc*/ +#define LOC_NAV_DATA_HAS_LAT_ACCEL_UNC ((LocPosDataMask)0x0040) +/* Bitmask to specify whether Navigation data has Vertical Acceleration Unc*/ +#define LOC_NAV_DATA_HAS_VERT_ACCEL_UNC ((LocPosDataMask)0x0080) +/* Bitmask to specify whether Navigation data has Heading Rate Unc*/ +#define LOC_NAV_DATA_HAS_YAW_RATE_UNC ((LocPosDataMask)0x0100) +/* Bitmask to specify whether Navigation data has Body pitch Unc*/ +#define LOC_NAV_DATA_HAS_PITCH_UNC ((LocPosDataMask)0x0200) /** GPS PRN Range */ #define GPS_SV_PRN_MIN 1 @@ -412,14 +422,24 @@ typedef struct { uint32_t bodyFrameDatamask; /* Forward Acceleration in body frame (m/s2)*/ float longAccel; + /** Uncertainty of Forward Acceleration in body frame */ + float longAccelUnc; /* Sideward Acceleration in body frame (m/s2)*/ float latAccel; + /** Uncertainty of Side-ward Acceleration in body frame */ + float latAccelUnc; /* Vertical Acceleration in body frame (m/s2)*/ float vertAccel; + /** Uncertainty of Vertical Acceleration in body frame */ + float vertAccelUnc; /* Heading Rate (Radians/second) */ float yawRate; + /** Uncertainty of Heading Rate */ + float yawRateUnc; /* Body pitch (Radians) */ float pitch; + /** Uncertainty of Body pitch */ + float pitchRadUnc; }LocPositionDynamics; typedef struct { From dc1e6f6f3469138aed389cd42e429d454ffc1c07 Mon Sep 17 00:00:00 2001 From: Bhavna Sharma Date: Wed, 13 Jun 2018 15:10:43 -0700 Subject: [PATCH 11/14] Changed to allow only locclient group to access hal daemon Move hal daemon socket creation to loc_client directory Define uid/gid for locclient CRs-Fixed: 2260194 Change-Id: Icaac885c19cd65b11254bb93b6a938b2d4595761 --- pla/oe/loc_pla.h | 2 ++ utils/gps_extended_c.h | 2 +- 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/pla/oe/loc_pla.h b/pla/oe/loc_pla.h index 094e3f33..94468881 100644 --- a/pla/oe/loc_pla.h +++ b/pla/oe/loc_pla.h @@ -64,6 +64,8 @@ extern "C" { #define UID_GPS (1021) #define GID_GPS (1021) +#define UID_LOCCLIENT (4021) +#define GID_LOCCLIENT (4021) #define LOC_PATH_GPS_CONF_STR "/etc/gps.conf" #define LOC_PATH_IZAT_CONF_STR "/etc/izat.conf" diff --git a/utils/gps_extended_c.h b/utils/gps_extended_c.h index ea38eb38..7720489a 100644 --- a/utils/gps_extended_c.h +++ b/utils/gps_extended_c.h @@ -1505,7 +1505,7 @@ typedef void (*LocAgpsCloseResultCb)(bool isSuccess, AGpsExtType agpsType, void* #define SOCKET_DIR_LOCATION "/dev/socket/location/" #define SOCKET_DIR_EHUB "/dev/socket/location/ehub/" -#define SOCKET_TO_LOCATION_HAL_DAEMON "/dev/socket/location/hal_daemon" +#define SOCKET_TO_LOCATION_HAL_DAEMON "/dev/socket/loc_client/hal_daemon" #define SOCKET_DIR_TO_CLIENT "/dev/socket/loc_client/" #define SOCKET_TO_LOCATION_CLIENT_BASE "/dev/socket/loc_client/toclient" From 02cddf0f260b4c0b78aec15272f3594de8a8ec8c Mon Sep 17 00:00:00 2001 From: Naresh Munagala Date: Thu, 21 Jun 2018 10:44:51 +0530 Subject: [PATCH 12/14] GNSS hal: propagate position dynamics uncertainty Support for uncertainty of positition dynamics, including uncertainty of forward, sideward, upward accelation, and uncertainty of heading and pitch Change-Id: I33fbfd0344d4beb7eabaa629b0c0993fe368293b CRs-fixed: 2263818 --- gnss/GnssAdapter.cpp | 28 +++----------------- location/LocationDataTypes.h | 17 +++++++++++- utils/gps_extended_c.h | 50 +----------------------------------- 3 files changed, 20 insertions(+), 75 deletions(-) diff --git a/gnss/GnssAdapter.cpp b/gnss/GnssAdapter.cpp index ef835aee..e22bee09 100644 --- a/gnss/GnssAdapter.cpp +++ b/gnss/GnssAdapter.cpp @@ -380,34 +380,12 @@ GnssAdapter::convertLocationInfo(GnssLocationInfoNotification& out, out.navSolutionMask = locationExtended.navSolutionMask; } if (GPS_LOCATION_EXTENDED_HAS_POS_TECH_MASK & locationExtended.flags) { - out.flags |= GPS_LOCATION_EXTENDED_HAS_POS_TECH_MASK; + out.flags |= GNSS_LOCATION_INFO_POS_TECH_MASK_BIT; out.posTechMask = locationExtended.tech_mask; } if (GPS_LOCATION_EXTENDED_HAS_POS_DYNAMICS_DATA & locationExtended.flags) { - out.flags |= GPS_LOCATION_EXTENDED_HAS_POS_DYNAMICS_DATA; - if (locationExtended.bodyFrameData.bodyFrameDatamask & - LOCATION_NAV_DATA_HAS_LONG_ACCEL_BIT) { - out.bodyFrameData.bodyFrameDataMask |= LOCATION_NAV_DATA_HAS_LONG_ACCEL_BIT; - } - if (locationExtended.bodyFrameData.bodyFrameDatamask & - LOCATION_NAV_DATA_HAS_LAT_ACCEL_BIT) { - out.bodyFrameData.bodyFrameDataMask |= LOCATION_NAV_DATA_HAS_LAT_ACCEL_BIT; - } - if (locationExtended.bodyFrameData.bodyFrameDatamask & - LOCATION_NAV_DATA_HAS_VERT_ACCEL_BIT) { - out.bodyFrameData.bodyFrameDataMask |= LOCATION_NAV_DATA_HAS_VERT_ACCEL_BIT; - } - if (locationExtended.bodyFrameData.bodyFrameDatamask & LOCATION_NAV_DATA_HAS_YAW_RATE_BIT) { - out.bodyFrameData.bodyFrameDataMask |= LOCATION_NAV_DATA_HAS_YAW_RATE_BIT; - } - if (locationExtended.bodyFrameData.bodyFrameDatamask & LOCATION_NAV_DATA_HAS_PITCH_BIT) { - out.bodyFrameData.bodyFrameDataMask |= LOCATION_NAV_DATA_HAS_PITCH_BIT; - } - out.bodyFrameData.longAccel = locationExtended.bodyFrameData.longAccel; - out.bodyFrameData.latAccel = locationExtended.bodyFrameData.latAccel; - out.bodyFrameData.vertAccel = locationExtended.bodyFrameData.vertAccel; - out.bodyFrameData.yawRate = locationExtended.bodyFrameData.yawRate; - out.bodyFrameData.pitch = locationExtended.bodyFrameData.pitch; + out.flags |= GNSS_LOCATION_INFO_POS_DYNAMICS_DATA_BIT; + out.bodyFrameData = locationExtended.bodyFrameData; } // Validity of this structure is established from the timeSrc of the GnssSystemTime structure. diff --git a/location/LocationDataTypes.h b/location/LocationDataTypes.h index 8bb11cc7..e40dcaab 100644 --- a/location/LocationDataTypes.h +++ b/location/LocationDataTypes.h @@ -119,7 +119,17 @@ typedef enum { LOCATION_NAV_DATA_HAS_LAT_ACCEL_BIT = (1<<1), // Navigation data has Sideward Acceleration LOCATION_NAV_DATA_HAS_VERT_ACCEL_BIT = (1<<2), // Navigation data has Vertical Acceleration LOCATION_NAV_DATA_HAS_YAW_RATE_BIT = (1<<3), // Navigation data has Heading Rate - LOCATION_NAV_DATA_HAS_PITCH_BIT = (1<<4) // Navigation data has Body pitch + LOCATION_NAV_DATA_HAS_PITCH_BIT = (1<<4), // Navigation data has Body pitch + // Navigation data has Forward Acceleration uncertainty + LOCATION_NAV_DATA_HAS_LONG_ACCEL_UNC_BIT = (1<<5), + // Navigation data has Sideward Acceleration uncertainty + LOCATION_NAV_DATA_HAS_LAT_ACCEL_UNC_BIT = (1<<6), + // Navigation data has Vertical Acceleration uncertainty + LOCATION_NAV_DATA_HAS_VERT_ACCEL_UNC_BIT = (1<<7), + // Navigation data has Heading Rate uncertainty + LOCATION_NAV_DATA_HAS_YAW_RATE_UNC_BIT = (1<<8), + // Navigation data has Body pitch uncertainty + LOCATION_NAV_DATA_HAS_PITCH_UNC_BIT = (1<<9) } GnssLocationPosDataBits; typedef uint32_t GnssLocationInfoFlagMask; @@ -658,6 +668,11 @@ typedef struct { float vertAccel; // Vertical Acceleration in body frame (m/s2) float yawRate; // Heading Rate (Radians/second) float pitch; // Body pitch (Radians) + float longAccelUnc; // Uncertainty of Forward Acceleration in body frame + float latAccelUnc; // Uncertainty of Side-ward Acceleration in body frame + float vertAccelUnc; // Uncertainty of Vertical Acceleration in body frame + float yawRateUnc; // Uncertainty of Heading Rate + float pitchUnc; // Uncertainty of Body pitch } GnssLocationPositionDynamics; typedef struct { diff --git a/utils/gps_extended_c.h b/utils/gps_extended_c.h index 5f9dead9..aff87e96 100644 --- a/utils/gps_extended_c.h +++ b/utils/gps_extended_c.h @@ -353,28 +353,6 @@ typedef uint32_t LocNavSolutionMask; /**< Bitmask to specify whether Position Report is PPP corrected */ #define LOC_NAV_MASK_PPP_CORRECTION ((LocNavSolutionMask)0x0040) -typedef uint32_t LocPosDataMask; -/* Bitmask to specify whether Navigation data has Forward Acceleration */ -#define LOC_NAV_DATA_HAS_LONG_ACCEL ((LocPosDataMask)0x0001) -/* Bitmask to specify whether Navigation data has Sideward Acceleration */ -#define LOC_NAV_DATA_HAS_LAT_ACCEL ((LocPosDataMask)0x0002) -/* Bitmask to specify whether Navigation data has Vertical Acceleration */ -#define LOC_NAV_DATA_HAS_VERT_ACCEL ((LocPosDataMask)0x0004) -/* Bitmask to specify whether Navigation data has Heading Rate */ -#define LOC_NAV_DATA_HAS_YAW_RATE ((LocPosDataMask)0x0008) -/* Bitmask to specify whether Navigation data has Body pitch */ -#define LOC_NAV_DATA_HAS_PITCH ((LocPosDataMask)0x0010) -/* Bitmask to specify whether Navigation data has Forward Acceleration Unc */ -#define LOC_NAV_DATA_HAS_LONG_ACCEL_UNC ((LocPosDataMask)0x0020) -/* Bitmask to specify whether Navigation data has Sideward Acceleration Unc*/ -#define LOC_NAV_DATA_HAS_LAT_ACCEL_UNC ((LocPosDataMask)0x0040) -/* Bitmask to specify whether Navigation data has Vertical Acceleration Unc*/ -#define LOC_NAV_DATA_HAS_VERT_ACCEL_UNC ((LocPosDataMask)0x0080) -/* Bitmask to specify whether Navigation data has Heading Rate Unc*/ -#define LOC_NAV_DATA_HAS_YAW_RATE_UNC ((LocPosDataMask)0x0100) -/* Bitmask to specify whether Navigation data has Body pitch Unc*/ -#define LOC_NAV_DATA_HAS_PITCH_UNC ((LocPosDataMask)0x0200) - /** GPS PRN Range */ #define GPS_SV_PRN_MIN 1 #define GPS_SV_PRN_MAX 32 @@ -421,32 +399,6 @@ typedef struct { uint64_t qzss_sv_used_ids_mask; } GnssSvUsedInPosition; -/* Body Frame parameters */ -typedef struct { - /** Contains Body frame LocPosDataMask bits. */ - uint32_t bodyFrameDatamask; - /* Forward Acceleration in body frame (m/s2)*/ - float longAccel; - /** Uncertainty of Forward Acceleration in body frame */ - float longAccelUnc; - /* Sideward Acceleration in body frame (m/s2)*/ - float latAccel; - /** Uncertainty of Side-ward Acceleration in body frame */ - float latAccelUnc; - /* Vertical Acceleration in body frame (m/s2)*/ - float vertAccel; - /** Uncertainty of Vertical Acceleration in body frame */ - float vertAccelUnc; - /* Heading Rate (Radians/second) */ - float yawRate; - /** Uncertainty of Heading Rate */ - float yawRateUnc; - /* Body pitch (Radians) */ - float pitch; - /** Uncertainty of Body pitch */ - float pitchRadUnc; -}LocPositionDynamics; - typedef struct { /** Position dilution of precision. @@ -636,7 +588,7 @@ typedef struct { /** SV Info source used in computing this fix */ LocSvInfoSource sv_source; /** Body Frame Dynamics: 4wayAcceleration and pitch set with validity */ - LocPositionDynamics bodyFrameData; + GnssLocationPositionDynamics bodyFrameData; /** GPS Time */ GPSTimeStruct gpsTime; GnssSystemTime gnssSystemTime; From 1e871997d65d6479d0950b52e0c52c795f73cf70 Mon Sep 17 00:00:00 2001 From: Hoss Zhou Date: Wed, 27 Jun 2018 15:20:21 +0800 Subject: [PATCH 13/14] Fix: wrong string format operator a log print in LocCloseMsg print a string without dereferenced address, and it will cause null pointer dereference. Change-Id: I0daf7cbf09033e065e07825f842320ae5d2508cb CRs-Fixed: 2259999 --- core/LocApiBase.cpp | 1 - 1 file changed, 1 deletion(-) diff --git a/core/LocApiBase.cpp b/core/LocApiBase.cpp index 8981e8b8..98aa50b8 100644 --- a/core/LocApiBase.cpp +++ b/core/LocApiBase.cpp @@ -137,7 +137,6 @@ struct LocCloseMsg : public LocMsg { mLocApi->close(); } inline void locallog() const { - LOC_LOGV("%s]: LocCloseMsg"); } inline virtual void log() const { locallog(); From 395c8110d6b9c4f09b9f537402fc5656c1557c81 Mon Sep 17 00:00:00 2001 From: Dante Russo Date: Thu, 5 Apr 2018 17:54:50 -0700 Subject: [PATCH 14/14] Assure event mask is set properly to get positions The event mask can be retrieved in the context of client thread as zero and then queued up to go to msg task thread. By the time the msg is actually handled in msg task thread, the actual event mask at LOC API layer may have already changed, but this mask would then be overridden by zero. This can cause no modem events to ever come, including position reports. The fix is to not retrieve the event mask in the client thread, but instead wait for msg to be handled in msg task thread before retrieving it. Change-Id: I48562d028bbfa187732686c060b5cdd62c6d5a89 CRs-fixed: 2219519 --- core/LocApiBase.cpp | 18 +++++++----------- 1 file changed, 7 insertions(+), 11 deletions(-) diff --git a/core/LocApiBase.cpp b/core/LocApiBase.cpp index 98aa50b8..d4e0fd6e 100644 --- a/core/LocApiBase.cpp +++ b/core/LocApiBase.cpp @@ -107,19 +107,16 @@ struct LocSsrMsg : public LocMsg { struct LocOpenMsg : public LocMsg { LocApiBase* mLocApi; - LOC_API_ADAPTER_EVENT_MASK_T mMask; - inline LocOpenMsg(LocApiBase* locApi, - LOC_API_ADAPTER_EVENT_MASK_T mask) : - LocMsg(), mLocApi(locApi), mMask(mask) + inline LocOpenMsg(LocApiBase* locApi) : + LocMsg(), mLocApi(locApi) { locallog(); } inline virtual void proc() const { - mLocApi->open(mMask); + mLocApi->open(mLocApi->getEvtMask()); } inline void locallog() const { - LOC_LOGV("%s:%d]: LocOpen Mask: %x\n", - __func__, __LINE__, mMask); + LOC_LOGv("LocOpen Mask: %" PRIx64 "\n", mLocApi->getEvtMask()); } inline virtual void log() const { locallog(); @@ -184,8 +181,7 @@ void LocApiBase::addAdapter(LocAdapterBase* adapter) for (int i = 0; i < MAX_ADAPTERS && mLocAdapters[i] != adapter; i++) { if (mLocAdapters[i] == NULL) { mLocAdapters[i] = adapter; - mMsgTask->sendMsg(new LocOpenMsg(this, - mMask | adapter->getEvtMask())); + mMsgTask->sendMsg(new LocOpenMsg(this)); break; } } @@ -221,7 +217,7 @@ void LocApiBase::removeAdapter(LocAdapterBase* adapter) mMsgTask->sendMsg(new LocCloseMsg(this)); } else { // else we need to remove the bit - mMsgTask->sendMsg(new LocOpenMsg(this, getEvtMask())); + mMsgTask->sendMsg(new LocOpenMsg(this)); } } } @@ -229,7 +225,7 @@ void LocApiBase::removeAdapter(LocAdapterBase* adapter) void LocApiBase::updateEvtMask() { - mMsgTask->sendMsg(new LocOpenMsg(this, getEvtMask())); + mMsgTask->sendMsg(new LocOpenMsg(this)); } void LocApiBase::handleEngineUpEvent()