From 36e5c637a7b8c6a1a447924f59e53631a726f16a Mon Sep 17 00:00:00 2001 From: OdSazib Date: Wed, 27 Jan 2021 07:29:04 +0600 Subject: [PATCH] sdm660-common: gps: Checkout gps hal from LA.UM.8.2.r1-07400-sdm660.0 * Removed depricated dependencies * Restored needed config for gps Signed-off-by: OdSazib --- gps/android/1.0/Gnss.cpp | 7 +- gps/android/1.0/GnssBatching.cpp | 4 +- gps/android/1.0/GnssGeofencing.cpp | 2 +- gps/android/1.0/GnssMeasurement.cpp | 2 +- .../1.0/location_api/BatchingAPIClient.h | 2 +- .../1.0/location_api/GeofenceAPIClient.h | 3 +- .../1.0/location_api/GnssAPIClient.cpp | 21 +-- gps/android/1.0/location_api/GnssAPIClient.h | 3 +- .../1.0/location_api/MeasurementAPIClient.h | 2 +- gps/android/1.1/Gnss.cpp | 7 +- gps/android/1.1/GnssBatching.cpp | 4 +- gps/android/1.1/GnssGeofencing.cpp | 2 +- gps/android/1.1/GnssMeasurement.cpp | 2 +- .../1.1/location_api/BatchingAPIClient.h | 3 +- .../1.1/location_api/GeofenceAPIClient.h | 6 +- .../1.1/location_api/GnssAPIClient.cpp | 21 +-- gps/android/1.1/location_api/GnssAPIClient.h | 2 +- .../1.1/location_api/MeasurementAPIClient.h | 3 +- gps/android/2.0/Gnss.cpp | 45 ++++- gps/android/2.0/Gnss.h | 3 +- gps/android/2.0/GnssBatching.cpp | 6 +- gps/android/2.0/GnssGeofencing.cpp | 2 +- gps/android/2.0/GnssMeasurement.cpp | 2 +- .../2.0/location_api/BatchingAPIClient.h | 2 +- .../2.0/location_api/GeofenceAPIClient.h | 4 +- .../2.0/location_api/GnssAPIClient.cpp | 47 +++-- gps/android/2.0/location_api/GnssAPIClient.h | 4 +- gps/android/2.0/location_api/LocationUtil.cpp | 7 +- .../2.0/location_api/MeasurementAPIClient.cpp | 15 +- .../2.0/location_api/MeasurementAPIClient.h | 3 +- gps/build/target_specific_features.mk | 4 +- gps/core/ContextBase.cpp | 3 + gps/core/ContextBase.h | 3 +- gps/core/loc_core_log.cpp | 58 +++--- gps/etc/Android.mk | 21 +++ gps/etc/flp.conf | 34 ---- gps/etc/gps.conf | 31 +--- gps/gnss/GnssAdapter.cpp | 22 ++- gps/gnss/GnssAdapter.h | 7 + gps/gnss/location_gnss.cpp | 9 + gps/location/LocationAPI.cpp | 14 +- gps/location/LocationAPIClientBase.cpp | 37 +++- gps/location/LocationAPIClientBase.h | 11 +- gps/location/location_interface.h | 1 + gps/utils/gps_extended_c.h | 7 + gps/utils/loc_cfg.cpp | 66 +++---- gps/utils/loc_log.cpp | 85 ++++----- gps/utils/loc_log.h | 97 +++++++--- gps/utils/loc_misc_utils.h | 64 ++++++- gps/utils/loc_nmea.cpp | 166 ++++++++++++------ 50 files changed, 617 insertions(+), 359 deletions(-) create mode 100644 gps/etc/Android.mk diff --git a/gps/android/1.0/Gnss.cpp b/gps/android/1.0/Gnss.cpp index fda58f20..06a94d48 100644 --- a/gps/android/1.0/Gnss.cpp +++ b/gps/android/1.0/Gnss.cpp @@ -70,7 +70,7 @@ Gnss::Gnss() { Gnss::~Gnss() { ENTRY_LOG_CALLFLOW(); if (mApi != nullptr) { - delete mApi; + mApi->destroy(); mApi = nullptr; } sGnss = nullptr; @@ -254,6 +254,11 @@ Return Gnss::injectLocation(double latitudeDegrees, Return Gnss::injectTime(int64_t timeMs, int64_t timeReferenceMs, int32_t uncertaintyMs) { + ENTRY_LOG_CALLFLOW(); + const GnssInterface* gnssInterface = getGnssInterface(); + if ((nullptr != gnssInterface) && (gnssInterface->isSS5HWEnabled())) { + gnssInterface->injectTime(timeMs, timeReferenceMs, uncertaintyMs); + } return true; } diff --git a/gps/android/1.0/GnssBatching.cpp b/gps/android/1.0/GnssBatching.cpp index 3e5a9f4a..f92697ff 100644 --- a/gps/android/1.0/GnssBatching.cpp +++ b/gps/android/1.0/GnssBatching.cpp @@ -46,7 +46,7 @@ GnssBatching::GnssBatching() : mApi(nullptr) { GnssBatching::~GnssBatching() { if (mApi != nullptr) { - delete mApi; + mApi->destroy(); mApi = nullptr; } } @@ -56,7 +56,7 @@ GnssBatching::~GnssBatching() { Return GnssBatching::init(const sp& callback) { if (mApi != nullptr) { LOC_LOGD("%s]: mApi is NOT nullptr, delete it first", __FUNCTION__); - delete mApi; + mApi->destroy(); mApi = nullptr; } diff --git a/gps/android/1.0/GnssGeofencing.cpp b/gps/android/1.0/GnssGeofencing.cpp index 2a8ff88d..4be6d8ae 100644 --- a/gps/android/1.0/GnssGeofencing.cpp +++ b/gps/android/1.0/GnssGeofencing.cpp @@ -45,7 +45,7 @@ GnssGeofencing::GnssGeofencing() : mApi(nullptr) { GnssGeofencing::~GnssGeofencing() { if (mApi != nullptr) { - delete mApi; + mApi->destroy(); mApi = nullptr; } } diff --git a/gps/android/1.0/GnssMeasurement.cpp b/gps/android/1.0/GnssMeasurement.cpp index 1c65bd6d..7af9e272 100644 --- a/gps/android/1.0/GnssMeasurement.cpp +++ b/gps/android/1.0/GnssMeasurement.cpp @@ -46,7 +46,7 @@ GnssMeasurement::GnssMeasurement() { GnssMeasurement::~GnssMeasurement() { if (mApi) { - delete mApi; + mApi->destroy(); mApi = nullptr; } } diff --git a/gps/android/1.0/location_api/BatchingAPIClient.h b/gps/android/1.0/location_api/BatchingAPIClient.h index 5d64df3f..f98726f7 100644 --- a/gps/android/1.0/location_api/BatchingAPIClient.h +++ b/gps/android/1.0/location_api/BatchingAPIClient.h @@ -46,7 +46,6 @@ class BatchingAPIClient : public LocationAPIClientBase { public: BatchingAPIClient(const sp& callback); - ~BatchingAPIClient(); int getBatchSize(); int startSession(const V1_0::IGnssBatching::Options& options); int updateSessionOptions(const V1_0::IGnssBatching::Options& options); @@ -61,6 +60,7 @@ public: void onBatchingCb(size_t count, Location* location, BatchingOptions batchOptions) final; private: + ~BatchingAPIClient(); sp mGnssBatchingCbIface; uint32_t mDefaultId; LocationCapabilitiesMask mLocationCapabilitiesMask; diff --git a/gps/android/1.0/location_api/GeofenceAPIClient.h b/gps/android/1.0/location_api/GeofenceAPIClient.h index dc99ddd1..94aada70 100644 --- a/gps/android/1.0/location_api/GeofenceAPIClient.h +++ b/gps/android/1.0/location_api/GeofenceAPIClient.h @@ -46,8 +46,6 @@ class GeofenceAPIClient : public LocationAPIClientBase { public: GeofenceAPIClient(const sp& callback); - virtual ~GeofenceAPIClient() = default; - void geofenceAdd(uint32_t geofence_id, double latitude, double longitude, double radius_meters, int32_t last_transition, int32_t monitor_transitions, uint32_t notification_responsiveness_ms, uint32_t unknown_timer_ms); @@ -65,6 +63,7 @@ public: void onResumeGeofencesCb(size_t count, LocationError* errors, uint32_t* ids) final; private: + virtual ~GeofenceAPIClient() = default; sp mGnssGeofencingCbIface; }; diff --git a/gps/android/1.0/location_api/GnssAPIClient.cpp b/gps/android/1.0/location_api/GnssAPIClient.cpp index c474d453..27be0fcc 100644 --- a/gps/android/1.0/location_api/GnssAPIClient.cpp +++ b/gps/android/1.0/location_api/GnssAPIClient.cpp @@ -331,16 +331,17 @@ void GnssAPIClient::onCapabilitiesCb(LocationCapabilitiesMask capabilitiesMask) } } if (gnssCbIface != nullptr) { - IGnssCallback::GnssSystemInfo gnssInfo; - if (capabilitiesMask & LOCATION_CAPABILITIES_CONSTELLATION_ENABLEMENT_BIT || - capabilitiesMask & LOCATION_CAPABILITIES_AGPM_BIT) { - gnssInfo.yearOfHw = 2018; - } else if (capabilitiesMask & LOCATION_CAPABILITIES_DEBUG_NMEA_BIT) { - gnssInfo.yearOfHw = 2017; - } else if (capabilitiesMask & LOCATION_CAPABILITIES_GNSS_MEASUREMENTS_BIT) { - gnssInfo.yearOfHw = 2016; - } else { - gnssInfo.yearOfHw = 2015; + IGnssCallback::GnssSystemInfo gnssInfo = { .yearOfHw = 2015 }; + + if (capabilitiesMask & LOCATION_CAPABILITIES_GNSS_MEASUREMENTS_BIT) { + gnssInfo.yearOfHw++; // 2016 + if (capabilitiesMask & LOCATION_CAPABILITIES_DEBUG_NMEA_BIT) { + gnssInfo.yearOfHw++; // 2017 + if (capabilitiesMask & LOCATION_CAPABILITIES_CONSTELLATION_ENABLEMENT_BIT || + capabilitiesMask & LOCATION_CAPABILITIES_AGPM_BIT) { + gnssInfo.yearOfHw++; // 2018 + } + } } LOC_LOGV("%s:%d] set_system_info_cb (%d)", __FUNCTION__, __LINE__, gnssInfo.yearOfHw); auto r = gnssCbIface->gnssSetSystemInfoCb(gnssInfo); diff --git a/gps/android/1.0/location_api/GnssAPIClient.h b/gps/android/1.0/location_api/GnssAPIClient.h index 4e4b4a9b..427b0db2 100644 --- a/gps/android/1.0/location_api/GnssAPIClient.h +++ b/gps/android/1.0/location_api/GnssAPIClient.h @@ -50,7 +50,6 @@ class GnssAPIClient : public LocationAPIClientBase public: GnssAPIClient(const sp& gpsCb, const sp& niCb); - virtual ~GnssAPIClient(); GnssAPIClient(const GnssAPIClient&) = delete; GnssAPIClient& operator=(const GnssAPIClient&) = delete; @@ -92,6 +91,8 @@ public: void onStopTrackingCb(LocationError error) final; private: + virtual ~GnssAPIClient(); + sp mGnssCbIface; sp mGnssNiCbIface; std::mutex mMutex; diff --git a/gps/android/1.0/location_api/MeasurementAPIClient.h b/gps/android/1.0/location_api/MeasurementAPIClient.h index c357313a..1b322513 100644 --- a/gps/android/1.0/location_api/MeasurementAPIClient.h +++ b/gps/android/1.0/location_api/MeasurementAPIClient.h @@ -49,7 +49,6 @@ class MeasurementAPIClient : public LocationAPIClientBase { public: MeasurementAPIClient(); - virtual ~MeasurementAPIClient(); MeasurementAPIClient(const MeasurementAPIClient&) = delete; MeasurementAPIClient& operator=(const MeasurementAPIClient&) = delete; @@ -63,6 +62,7 @@ public: void onGnssMeasurementsCb(GnssMeasurementsNotification gnssMeasurementsNotification) final; private: + virtual ~MeasurementAPIClient(); std::mutex mMutex; sp mGnssMeasurementCbIface; diff --git a/gps/android/1.1/Gnss.cpp b/gps/android/1.1/Gnss.cpp index 2e2a52ad..0babbc4f 100644 --- a/gps/android/1.1/Gnss.cpp +++ b/gps/android/1.1/Gnss.cpp @@ -111,7 +111,7 @@ Gnss::Gnss() { Gnss::~Gnss() { ENTRY_LOG_CALLFLOW(); if (mApi != nullptr) { - delete mApi; + mApi->destroy(); mApi = nullptr; } sGnss = nullptr; @@ -295,6 +295,11 @@ Return Gnss::injectLocation(double latitudeDegrees, Return Gnss::injectTime(int64_t timeMs, int64_t timeReferenceMs, int32_t uncertaintyMs) { + ENTRY_LOG_CALLFLOW(); + const GnssInterface* gnssInterface = getGnssInterface(); + if ((nullptr != gnssInterface) && (gnssInterface->isSS5HWEnabled())) { + gnssInterface->injectTime(timeMs, timeReferenceMs, uncertaintyMs); + } return true; } diff --git a/gps/android/1.1/GnssBatching.cpp b/gps/android/1.1/GnssBatching.cpp index 9701affe..8ab264dd 100644 --- a/gps/android/1.1/GnssBatching.cpp +++ b/gps/android/1.1/GnssBatching.cpp @@ -46,7 +46,7 @@ GnssBatching::GnssBatching() : mApi(nullptr) { GnssBatching::~GnssBatching() { if (mApi != nullptr) { - delete mApi; + mApi->destroy(); mApi = nullptr; } } @@ -56,7 +56,7 @@ GnssBatching::~GnssBatching() { Return GnssBatching::init(const sp& callback) { if (mApi != nullptr) { LOC_LOGD("%s]: mApi is NOT nullptr, delete it first", __FUNCTION__); - delete mApi; + mApi->destroy(); mApi = nullptr; } diff --git a/gps/android/1.1/GnssGeofencing.cpp b/gps/android/1.1/GnssGeofencing.cpp index d57a6667..a4aaf883 100644 --- a/gps/android/1.1/GnssGeofencing.cpp +++ b/gps/android/1.1/GnssGeofencing.cpp @@ -45,7 +45,7 @@ GnssGeofencing::GnssGeofencing() : mApi(nullptr) { GnssGeofencing::~GnssGeofencing() { if (mApi != nullptr) { - delete mApi; + mApi->destroy(); mApi = nullptr; } } diff --git a/gps/android/1.1/GnssMeasurement.cpp b/gps/android/1.1/GnssMeasurement.cpp index ffe5c524..6f8c14d1 100644 --- a/gps/android/1.1/GnssMeasurement.cpp +++ b/gps/android/1.1/GnssMeasurement.cpp @@ -46,7 +46,7 @@ GnssMeasurement::GnssMeasurement() { GnssMeasurement::~GnssMeasurement() { if (mApi) { - delete mApi; + mApi->destroy(); mApi = nullptr; } } diff --git a/gps/android/1.1/location_api/BatchingAPIClient.h b/gps/android/1.1/location_api/BatchingAPIClient.h index 64d47a01..4c90626d 100644 --- a/gps/android/1.1/location_api/BatchingAPIClient.h +++ b/gps/android/1.1/location_api/BatchingAPIClient.h @@ -46,7 +46,6 @@ class BatchingAPIClient : public LocationAPIClientBase { public: BatchingAPIClient(const sp& callback); - ~BatchingAPIClient(); int getBatchSize(); int startSession(const V1_0::IGnssBatching::Options& options); int updateSessionOptions(const V1_0::IGnssBatching::Options& options); @@ -61,6 +60,8 @@ public: void onBatchingCb(size_t count, Location* location, BatchingOptions batchOptions) final; private: + ~BatchingAPIClient(); + sp mGnssBatchingCbIface; uint32_t mDefaultId; LocationCapabilitiesMask mLocationCapabilitiesMask; diff --git a/gps/android/1.1/location_api/GeofenceAPIClient.h b/gps/android/1.1/location_api/GeofenceAPIClient.h index c74a59a3..3df50bbb 100644 --- a/gps/android/1.1/location_api/GeofenceAPIClient.h +++ b/gps/android/1.1/location_api/GeofenceAPIClient.h @@ -46,8 +46,6 @@ class GeofenceAPIClient : public LocationAPIClientBase { public: GeofenceAPIClient(const sp& callback); - virtual ~GeofenceAPIClient() = default; - void geofenceAdd(uint32_t geofence_id, double latitude, double longitude, double radius_meters, int32_t last_transition, int32_t monitor_transitions, uint32_t notification_responsiveness_ms, uint32_t unknown_timer_ms); @@ -65,7 +63,9 @@ public: void onResumeGeofencesCb(size_t count, LocationError* errors, uint32_t* ids) final; private: - sp mGnssGeofencingCbIface; + virtual ~GeofenceAPIClient() = default; + + sp mGnssGeofencingCbIface; }; } // namespace implementation diff --git a/gps/android/1.1/location_api/GnssAPIClient.cpp b/gps/android/1.1/location_api/GnssAPIClient.cpp index 80710898..7aa573b6 100644 --- a/gps/android/1.1/location_api/GnssAPIClient.cpp +++ b/gps/android/1.1/location_api/GnssAPIClient.cpp @@ -331,16 +331,17 @@ void GnssAPIClient::onCapabilitiesCb(LocationCapabilitiesMask capabilitiesMask) } } if (gnssCbIface != nullptr) { - IGnssCallback::GnssSystemInfo gnssInfo; - if (capabilitiesMask & LOCATION_CAPABILITIES_CONSTELLATION_ENABLEMENT_BIT || - capabilitiesMask & LOCATION_CAPABILITIES_AGPM_BIT) { - gnssInfo.yearOfHw = 2018; - } else if (capabilitiesMask & LOCATION_CAPABILITIES_DEBUG_NMEA_BIT) { - gnssInfo.yearOfHw = 2017; - } else if (capabilitiesMask & LOCATION_CAPABILITIES_GNSS_MEASUREMENTS_BIT) { - gnssInfo.yearOfHw = 2016; - } else { - gnssInfo.yearOfHw = 2015; + IGnssCallback::GnssSystemInfo gnssInfo = { .yearOfHw = 2015 }; + + if (capabilitiesMask & LOCATION_CAPABILITIES_GNSS_MEASUREMENTS_BIT) { + gnssInfo.yearOfHw++; // 2016 + if (capabilitiesMask & LOCATION_CAPABILITIES_DEBUG_NMEA_BIT) { + gnssInfo.yearOfHw++; // 2017 + if (capabilitiesMask & LOCATION_CAPABILITIES_CONSTELLATION_ENABLEMENT_BIT || + capabilitiesMask & LOCATION_CAPABILITIES_AGPM_BIT) { + gnssInfo.yearOfHw++; // 2018 + } + } } LOC_LOGV("%s:%d] set_system_info_cb (%d)", __FUNCTION__, __LINE__, gnssInfo.yearOfHw); auto r = gnssCbIface->gnssSetSystemInfoCb(gnssInfo); diff --git a/gps/android/1.1/location_api/GnssAPIClient.h b/gps/android/1.1/location_api/GnssAPIClient.h index 82f8fbfc..1c8737f6 100644 --- a/gps/android/1.1/location_api/GnssAPIClient.h +++ b/gps/android/1.1/location_api/GnssAPIClient.h @@ -50,7 +50,6 @@ class GnssAPIClient : public LocationAPIClientBase public: GnssAPIClient(const sp& gpsCb, const sp& niCb); - virtual ~GnssAPIClient(); GnssAPIClient(const GnssAPIClient&) = delete; GnssAPIClient& operator=(const GnssAPIClient&) = delete; @@ -92,6 +91,7 @@ public: void onStopTrackingCb(LocationError error) final; private: + virtual ~GnssAPIClient(); sp mGnssCbIface; sp mGnssNiCbIface; std::mutex mMutex; diff --git a/gps/android/1.1/location_api/MeasurementAPIClient.h b/gps/android/1.1/location_api/MeasurementAPIClient.h index 38811c55..5fb307c6 100644 --- a/gps/android/1.1/location_api/MeasurementAPIClient.h +++ b/gps/android/1.1/location_api/MeasurementAPIClient.h @@ -49,7 +49,6 @@ class MeasurementAPIClient : public LocationAPIClientBase { public: MeasurementAPIClient(); - virtual ~MeasurementAPIClient(); MeasurementAPIClient(const MeasurementAPIClient&) = delete; MeasurementAPIClient& operator=(const MeasurementAPIClient&) = delete; @@ -69,6 +68,8 @@ public: void onGnssMeasurementsCb(GnssMeasurementsNotification gnssMeasurementsNotification) final; private: + virtual ~MeasurementAPIClient(); + std::mutex mMutex; sp mGnssMeasurementCbIface; sp mGnssMeasurementCbIface_1_1; diff --git a/gps/android/2.0/Gnss.cpp b/gps/android/2.0/Gnss.cpp index e3c8b093..28352d25 100644 --- a/gps/android/2.0/Gnss.cpp +++ b/gps/android/2.0/Gnss.cpp @@ -34,7 +34,7 @@ typedef const GnssInterface* (getLocationInterface)(); #define IMAGES_INFO_FILE "/sys/devices/soc0/images" #define DELIMITER ";" - +#define MAX_GNSS_ACCURACY_ALLOWED 10000 namespace android { namespace hardware { namespace gnss { @@ -97,6 +97,7 @@ void location_on_battery_status_changed(bool charging) { Gnss::Gnss() { ENTRY_LOG_CALLFLOW(); sGnss = this; + mIsGnssClient = true; // initilize gnss interface at first in case needing notify battery status sGnss->getGnssInterface()->initialize(); // register health client to listen on battery change @@ -109,7 +110,7 @@ Gnss::Gnss() { Gnss::~Gnss() { ENTRY_LOG_CALLFLOW(); if (mApi != nullptr) { - delete mApi; + mApi->destroy(); mApi = nullptr; } sGnss = nullptr; @@ -190,6 +191,7 @@ Return Gnss::setCallback(const sp& callback) { GnssAPIClient* api = getApi(); if (api != nullptr) { + mIsGnssClient = true; api->gnssUpdateCallbacks(mGnssCbIface, mGnssNiCbIface); api->gnssEnable(LOCATION_TECHNOLOGY_TYPE_GNSS); api->requestCapabilities(); @@ -321,6 +323,11 @@ Return Gnss::injectLocation(double latitudeDegrees, Return Gnss::injectTime(int64_t timeMs, int64_t timeReferenceMs, int32_t uncertaintyMs) { + ENTRY_LOG_CALLFLOW(); + const GnssInterface* gnssInterface = getGnssInterface(); + if ((nullptr != gnssInterface) && (gnssInterface->isSS5HWEnabled())) { + gnssInterface->injectTime(timeMs, timeReferenceMs, uncertaintyMs); + } return true; } @@ -333,6 +340,28 @@ Return Gnss::deleteAidingData(V1_0::IGnss::GnssAidingData aidingDataFlags) return Void(); } +void Gnss::updateCallbacksByAccuracy(uint32_t preferredAccuracyMeters, GnssAPIClient* api) { + if (preferredAccuracyMeters >= MAX_GNSS_ACCURACY_ALLOWED && mIsGnssClient) { + // Swith to timebased FLP client, if request accuracy is very low + LOC_LOGd("Swith to timebased FlpClient due to low accuracy(m): %d", + preferredAccuracyMeters); + mIsGnssClient = false; + api->gnssUpdateFlpCallbacks(); + } else if (preferredAccuracyMeters < MAX_GNSS_ACCURACY_ALLOWED && !mIsGnssClient) { + LOC_LOGd("Swith to timebased GnssClient accuracy(m):%d", preferredAccuracyMeters); + mIsGnssClient = true; + if (mGnssCbIface_2_0 != nullptr) { + api->gnssUpdateCallbacks_2_0(mGnssCbIface_2_0); + } else if (mGnssCbIface_1_1 != nullptr) { + api->gnssUpdateCallbacks(mGnssCbIface_1_1, mGnssNiCbIface); + } else if (mGnssCbIface != nullptr) { + api->gnssUpdateCallbacks(mGnssCbIface, mGnssNiCbIface); + } else { + LOC_LOGe("All client callbacks are null..."); + } + } +} + Return Gnss::setPositionMode(V1_0::IGnss::GnssPositionMode mode, V1_0::IGnss::GnssPositionRecurrence recurrence, uint32_t minIntervalMs, @@ -342,7 +371,8 @@ Return Gnss::setPositionMode(V1_0::IGnss::GnssPositionMode mode, bool retVal = false; GnssAPIClient* api = getApi(); if (api) { - retVal = api->gnssSetPositionMode(mode, recurrence, minIntervalMs, + updateCallbacksByAccuracy(preferredAccuracyMeters, api); + retVal = api->gnssSetPositionMode(mode, recurrence, minIntervalMs, preferredAccuracyMeters, preferredTimeMs); } return retVal; @@ -450,6 +480,7 @@ Return Gnss::setCallback_1_1(const sp& callback) { GnssAPIClient* api = getApi(); if (api != nullptr) { + mIsGnssClient = true; api->gnssUpdateCallbacks(mGnssCbIface_1_1, mGnssNiCbIface); api->gnssEnable(LOCATION_TECHNOLOGY_TYPE_GNSS); api->requestCapabilities(); @@ -468,6 +499,7 @@ Return Gnss::setPositionMode_1_1(V1_0::IGnss::GnssPositionMode mode, bool retVal = false; GnssAPIClient* api = getApi(); if (api) { + updateCallbacksByAccuracy(preferredAccuracyMeters, api); GnssPowerMode powerMode = lowPowerMode? GNSS_POWER_MODE_M4 : GNSS_POWER_MODE_M2; retVal = api->gnssSetPositionMode(mode, recurrence, minIntervalMs, @@ -583,6 +615,7 @@ Return Gnss::setCallback_2_0(const sp& callback) { GnssAPIClient* api = getApi(); if (api != nullptr) { + mIsGnssClient = true; api->gnssUpdateCallbacks_2_0(mGnssCbIface_2_0); api->gnssEnable(LOCATION_TECHNOLOGY_TYPE_GNSS); api->requestCapabilities(); @@ -656,11 +689,7 @@ Return> Gnss::getExtensionGnssDebug_2_0() { } Return> Gnss::getExtensionGnssBatching_2_0() { - ENTRY_LOG_CALLFLOW(); - if (mGnssBatching == nullptr) { - mGnssBatching = new GnssBatching(); - } - return mGnssBatching; + return nullptr; } V1_0::IGnss* HIDL_FETCH_IGnss(const char* hal) { diff --git a/gps/android/2.0/Gnss.h b/gps/android/2.0/Gnss.h index a403d613..24c7f201 100644 --- a/gps/android/2.0/Gnss.h +++ b/gps/android/2.0/Gnss.h @@ -142,7 +142,7 @@ struct Gnss : public IGnss { // Callback for ODCPI request void odcpiRequestCb(const OdcpiRequestInfo& request); - + void updateCallbacksByAccuracy(uint32_t preferredAccuracyMeters, GnssAPIClient* api); private: struct GnssDeathRecipient : hidl_death_recipient { GnssDeathRecipient(sp gnss) : mGnss(gnss) { @@ -174,6 +174,7 @@ struct Gnss : public IGnss { GnssAPIClient* mApi = nullptr; GnssConfig mPendingConfig; const GnssInterface* mGnssInterface = nullptr; + bool mIsGnssClient; }; extern "C" V1_0::IGnss* HIDL_FETCH_IGnss(const char* name); diff --git a/gps/android/2.0/GnssBatching.cpp b/gps/android/2.0/GnssBatching.cpp index 7a937fc2..6a2a09e8 100644 --- a/gps/android/2.0/GnssBatching.cpp +++ b/gps/android/2.0/GnssBatching.cpp @@ -46,7 +46,7 @@ GnssBatching::GnssBatching() : mApi(nullptr) { GnssBatching::~GnssBatching() { if (mApi != nullptr) { - delete mApi; + mApi->destroy(); mApi = nullptr; } } @@ -56,7 +56,7 @@ GnssBatching::~GnssBatching() { Return GnssBatching::init(const sp& callback) { if (mApi != nullptr) { LOC_LOGD("%s]: mApi is NOT nullptr, delete it first", __FUNCTION__); - delete mApi; + mApi->destroy(); mApi = nullptr; } @@ -135,7 +135,7 @@ Return GnssBatching::cleanup() { Return GnssBatching::init_2_0(const sp& callback) { if (mApi != nullptr) { LOC_LOGD("%s]: mApi is NOT nullptr, delete it first", __FUNCTION__); - delete mApi; + mApi->destroy(); mApi = nullptr; } diff --git a/gps/android/2.0/GnssGeofencing.cpp b/gps/android/2.0/GnssGeofencing.cpp index b72d8353..b6fc94b2 100644 --- a/gps/android/2.0/GnssGeofencing.cpp +++ b/gps/android/2.0/GnssGeofencing.cpp @@ -45,7 +45,7 @@ GnssGeofencing::GnssGeofencing() : mApi(nullptr) { GnssGeofencing::~GnssGeofencing() { if (mApi != nullptr) { - delete mApi; + mApi->destroy(); mApi = nullptr; } } diff --git a/gps/android/2.0/GnssMeasurement.cpp b/gps/android/2.0/GnssMeasurement.cpp index 721a48c3..b21b0047 100644 --- a/gps/android/2.0/GnssMeasurement.cpp +++ b/gps/android/2.0/GnssMeasurement.cpp @@ -46,7 +46,7 @@ GnssMeasurement::GnssMeasurement() { GnssMeasurement::~GnssMeasurement() { if (mApi) { - delete mApi; + mApi->destroy(); mApi = nullptr; } } diff --git a/gps/android/2.0/location_api/BatchingAPIClient.h b/gps/android/2.0/location_api/BatchingAPIClient.h index 7198341a..a249b587 100644 --- a/gps/android/2.0/location_api/BatchingAPIClient.h +++ b/gps/android/2.0/location_api/BatchingAPIClient.h @@ -50,7 +50,6 @@ public: BatchingAPIClient(const sp& callback); void gnssUpdateCallbacks(const sp& callback); void gnssUpdateCallbacks_2_0(const sp& callback); - ~BatchingAPIClient(); int getBatchSize(); int startSession(const V1_0::IGnssBatching::Options& options); int updateSessionOptions(const V1_0::IGnssBatching::Options& options); @@ -66,6 +65,7 @@ public: private: void setCallbacks(); + ~BatchingAPIClient(); std::mutex mMutex; sp mGnssBatchingCbIface; uint32_t mDefaultId; diff --git a/gps/android/2.0/location_api/GeofenceAPIClient.h b/gps/android/2.0/location_api/GeofenceAPIClient.h index 71049de6..83025a92 100644 --- a/gps/android/2.0/location_api/GeofenceAPIClient.h +++ b/gps/android/2.0/location_api/GeofenceAPIClient.h @@ -46,8 +46,6 @@ class GeofenceAPIClient : public LocationAPIClientBase { public: GeofenceAPIClient(const sp& callback); - virtual ~GeofenceAPIClient() = default; - void geofenceAdd(uint32_t geofence_id, double latitude, double longitude, double radius_meters, int32_t last_transition, int32_t monitor_transitions, uint32_t notification_responsiveness_ms, uint32_t unknown_timer_ms); @@ -65,6 +63,8 @@ public: void onResumeGeofencesCb(size_t count, LocationError* errors, uint32_t* ids) final; private: + virtual ~GeofenceAPIClient() = default; + sp mGnssGeofencingCbIface; }; diff --git a/gps/android/2.0/location_api/GnssAPIClient.cpp b/gps/android/2.0/location_api/GnssAPIClient.cpp index 1fcf5300..74fe0366 100644 --- a/gps/android/2.0/location_api/GnssAPIClient.cpp +++ b/gps/android/2.0/location_api/GnssAPIClient.cpp @@ -105,13 +105,24 @@ void GnssAPIClient::initLocationOptions() mTrackingOptions.mode = GNSS_SUPL_MODE_STANDALONE; } +void GnssAPIClient::setFlpCallbacks() { + LOC_LOGd("Going to set Flp Callbacks..."); + LocationCallbacks locationCallbacks; + memset(&locationCallbacks, 0, sizeof(LocationCallbacks)); + locationCallbacks.size = sizeof(LocationCallbacks); + + locationCallbacks.trackingCb = [this](Location location) { + onTrackingCb(location); + }; + locAPISetCallbacks(locationCallbacks); +} + void GnssAPIClient::setCallbacks() { LocationCallbacks locationCallbacks; memset(&locationCallbacks, 0, sizeof(LocationCallbacks)); locationCallbacks.size = sizeof(LocationCallbacks); - locationCallbacks.trackingCb = nullptr; locationCallbacks.trackingCb = [this](Location location) { onTrackingCb(location); }; @@ -134,12 +145,10 @@ void GnssAPIClient::setCallbacks() } } - locationCallbacks.gnssSvCb = nullptr; locationCallbacks.gnssSvCb = [this](GnssSvNotification gnssSvNotification) { onGnssSvCb(gnssSvNotification); }; - locationCallbacks.gnssNmeaCb = nullptr; locationCallbacks.gnssNmeaCb = [this](GnssNmeaNotification gnssNmeaNotification) { onGnssNmeaCb(gnssNmeaNotification); }; @@ -178,6 +187,12 @@ void GnssAPIClient::gnssUpdateCallbacks_2_0(const sp& gpsCb } } +void GnssAPIClient::gnssUpdateFlpCallbacks() { + if (mGnssCbIface_2_0 != nullptr || mGnssCbIface != nullptr) { + setFlpCallbacks(); + } +} + bool GnssAPIClient::gnssStart() { LOC_LOGD("%s]: ()", __FUNCTION__); @@ -380,18 +395,20 @@ void GnssAPIClient::onCapabilitiesCb(LocationCapabilitiesMask capabilitiesMask) if (capabilitiesMask & LOCATION_CAPABILITIES_CONSTELLATION_ENABLEMENT_BIT) data |= IGnssCallback::Capabilities::SATELLITE_BLACKLIST; - IGnssCallback::GnssSystemInfo gnssInfo; - if (capabilitiesMask & LOCATION_CAPABILITIES_PRIVACY_BIT) { - gnssInfo.yearOfHw = 2019; - } else if (capabilitiesMask & LOCATION_CAPABILITIES_CONSTELLATION_ENABLEMENT_BIT || - capabilitiesMask & LOCATION_CAPABILITIES_AGPM_BIT) { - gnssInfo.yearOfHw = 2018; - } else if (capabilitiesMask & LOCATION_CAPABILITIES_DEBUG_NMEA_BIT) { - gnssInfo.yearOfHw = 2017; - } else if (capabilitiesMask & LOCATION_CAPABILITIES_GNSS_MEASUREMENTS_BIT) { - gnssInfo.yearOfHw = 2016; - } else { - gnssInfo.yearOfHw = 2015; + IGnssCallback::GnssSystemInfo gnssInfo = { .yearOfHw = 2015 }; + + if (capabilitiesMask & LOCATION_CAPABILITIES_GNSS_MEASUREMENTS_BIT) { + gnssInfo.yearOfHw++; // 2016 + if (capabilitiesMask & LOCATION_CAPABILITIES_DEBUG_NMEA_BIT) { + gnssInfo.yearOfHw++; // 2017 + if (capabilitiesMask & LOCATION_CAPABILITIES_CONSTELLATION_ENABLEMENT_BIT || + capabilitiesMask & LOCATION_CAPABILITIES_AGPM_BIT) { + gnssInfo.yearOfHw++; // 2018 + if (capabilitiesMask & LOCATION_CAPABILITIES_PRIVACY_BIT) { + gnssInfo.yearOfHw++; // 2019 + } + } + } } LOC_LOGV("%s:%d] set_system_info_cb (%d)", __FUNCTION__, __LINE__, gnssInfo.yearOfHw); diff --git a/gps/android/2.0/location_api/GnssAPIClient.h b/gps/android/2.0/location_api/GnssAPIClient.h index 63b45615..d6190a9b 100644 --- a/gps/android/2.0/location_api/GnssAPIClient.h +++ b/gps/android/2.0/location_api/GnssAPIClient.h @@ -50,7 +50,6 @@ public: GnssAPIClient(const sp& gpsCb, const sp& niCb); GnssAPIClient(const sp& gpsCb); - virtual ~GnssAPIClient(); GnssAPIClient(const GnssAPIClient&) = delete; GnssAPIClient& operator=(const GnssAPIClient&) = delete; @@ -58,6 +57,7 @@ public: void gnssUpdateCallbacks(const sp& gpsCb, const sp& niCb); void gnssUpdateCallbacks_2_0(const sp& gpsCb); + void gnssUpdateFlpCallbacks(); bool gnssStart(); bool gnssStop(); bool gnssSetPositionMode(V1_0::IGnss::GnssPositionMode mode, @@ -93,7 +93,9 @@ public: void onStopTrackingCb(LocationError error) final; private: + virtual ~GnssAPIClient(); void setCallbacks(); + void setFlpCallbacks(); void initLocationOptions(); sp mGnssCbIface; sp mGnssNiCbIface; diff --git a/gps/android/2.0/location_api/LocationUtil.cpp b/gps/android/2.0/location_api/LocationUtil.cpp index c2a75576..97cc2cf4 100644 --- a/gps/android/2.0/location_api/LocationUtil.cpp +++ b/gps/android/2.0/location_api/LocationUtil.cpp @@ -137,17 +137,16 @@ void convertGnssLocation(Location& in, V2_0::GnssLocation& out) if (currentTimeNanos >= locationTimeNanos) { int64_t ageTimeNanos = currentTimeNanos - locationTimeNanos; LOC_LOGD("%s]: ageTimeNanos:%" PRIi64 ")", __FUNCTION__, ageTimeNanos); - // the max trusted propagation time 30s for ageTimeNanos to avoid user setting + // the max trusted propagation time 100ms for ageTimeNanos to avoid user setting //wrong time, it will affect elapsedRealtimeNanos - if (ageTimeNanos >= 0 && ageTimeNanos <= 30000000000) { + if (ageTimeNanos <= 100000000) { out.elapsedRealtime.flags |= ElapsedRealtimeFlags::HAS_TIMESTAMP_NS; out.elapsedRealtime.timestampNs = sinceBootTimeNanos - ageTimeNanos; out.elapsedRealtime.flags |= ElapsedRealtimeFlags::HAS_TIME_UNCERTAINTY_NS; // time uncertainty is the max value between abs(AP_UTC - MP_UTC) and 100ms, to //verify if user change the sys time out.elapsedRealtime.timeUncertaintyNs = - std::max((int64_t)abs(currentTimeNanos - locationTimeNanos), - (int64_t)100000000); + std::max(ageTimeNanos, (int64_t)100000000); LOC_LOGD("%s]: timestampNs:%" PRIi64 ")", __FUNCTION__, out.elapsedRealtime.timestampNs); } diff --git a/gps/android/2.0/location_api/MeasurementAPIClient.cpp b/gps/android/2.0/location_api/MeasurementAPIClient.cpp index 5894e46e..f41fe94c 100644 --- a/gps/android/2.0/location_api/MeasurementAPIClient.cpp +++ b/gps/android/2.0/location_api/MeasurementAPIClient.cpp @@ -296,7 +296,7 @@ static void convertGnssMeasurement(GnssMeasurementsData& in, static void convertGnssClock(GnssMeasurementsClock& in, IGnssMeasurementCallback::GnssClock& out) { - memset(&out, 0, sizeof(IGnssMeasurementCallback::GnssClock)); + memset(&out, 0, sizeof(out)); if (in.flags & GNSS_MEASUREMENTS_CLOCK_FLAGS_LEAP_SECOND_BIT) out.gnssClockFlags |= IGnssMeasurementCallback::GnssClockFlags::HAS_LEAP_SECOND; if (in.flags & GNSS_MEASUREMENTS_CLOCK_FLAGS_TIME_UNCERTAINTY_BIT) @@ -325,6 +325,7 @@ static void convertGnssClock(GnssMeasurementsClock& in, IGnssMeasurementCallback static void convertGnssData(GnssMeasurementsNotification& in, V1_0::IGnssMeasurementCallback::GnssData& out) { + memset(&out, 0, sizeof(out)); out.measurementCount = in.count; if (out.measurementCount > static_cast(V1_0::GnssMax::SVS_COUNT)) { LOC_LOGW("%s]: Too many measurement %u. Clamps to %d.", @@ -340,6 +341,7 @@ static void convertGnssData(GnssMeasurementsNotification& in, static void convertGnssData_1_1(GnssMeasurementsNotification& in, V1_1::IGnssMeasurementCallback::GnssData& out) { + memset(&out, 0, sizeof(out)); out.measurements.resize(in.count); for (size_t i = 0; i < in.count; i++) { convertGnssMeasurement(in.measurements[i], out.measurements[i].v1_0); @@ -362,6 +364,7 @@ static void convertGnssData_1_1(GnssMeasurementsNotification& in, static void convertGnssData_2_0(GnssMeasurementsNotification& in, V2_0::IGnssMeasurementCallback::GnssData& out) { + memset(&out, 0, sizeof(out)); out.measurements.resize(in.count); for (size_t i = 0; i < in.count; i++) { convertGnssMeasurement(in.measurements[i], out.measurements[i].v1_1.v1_0); @@ -436,12 +439,16 @@ static void convertGnssData_2_0(GnssMeasurementsNotification& in, if (currentTimeNanos >= measTimeNanos) { int64_t ageTimeNanos = currentTimeNanos - measTimeNanos; LOC_LOGD("%s]: ageTimeNanos:%" PRIi64 ")", __FUNCTION__, ageTimeNanos); - if (ageTimeNanos >= 0 && ageTimeNanos <= sinceBootTimeNanos) { + // the max trusted propagation time 100ms for ageTimeNanos to avoid user setting + //wrong time, it will affect elapsedRealtimeNanos + if (ageTimeNanos <= 100000000) { out.elapsedRealtime.flags |= ElapsedRealtimeFlags::HAS_TIMESTAMP_NS; out.elapsedRealtime.timestampNs = sinceBootTimeNanos - ageTimeNanos; out.elapsedRealtime.flags |= ElapsedRealtimeFlags::HAS_TIME_UNCERTAINTY_NS; - // time uncertainty is 1 ms since it is calculated from utc time that is in ms - out.elapsedRealtime.timeUncertaintyNs = 1000000; + // time uncertainty is the max value between abs(AP_UTC - MP_UTC) and 100ms, to + //verify if user change the sys time + out.elapsedRealtime.timeUncertaintyNs = + std::max(ageTimeNanos, (int64_t)100000000); LOC_LOGd("timestampNs:%" PRIi64 ") timeUncertaintyNs:%" PRIi64 ")", out.elapsedRealtime.timestampNs, out.elapsedRealtime.timeUncertaintyNs); diff --git a/gps/android/2.0/location_api/MeasurementAPIClient.h b/gps/android/2.0/location_api/MeasurementAPIClient.h index 4146a131..67f17aed 100644 --- a/gps/android/2.0/location_api/MeasurementAPIClient.h +++ b/gps/android/2.0/location_api/MeasurementAPIClient.h @@ -49,7 +49,6 @@ class MeasurementAPIClient : public LocationAPIClientBase { public: MeasurementAPIClient(); - virtual ~MeasurementAPIClient(); MeasurementAPIClient(const MeasurementAPIClient&) = delete; MeasurementAPIClient& operator=(const MeasurementAPIClient&) = delete; @@ -73,6 +72,8 @@ public: void onGnssMeasurementsCb(GnssMeasurementsNotification gnssMeasurementsNotification) final; private: + virtual ~MeasurementAPIClient(); + std::mutex mMutex; sp mGnssMeasurementCbIface; sp mGnssMeasurementCbIface_1_1; diff --git a/gps/build/target_specific_features.mk b/gps/build/target_specific_features.mk index 241d67c8..55395983 100644 --- a/gps/build/target_specific_features.mk +++ b/gps/build/target_specific_features.mk @@ -23,11 +23,11 @@ GNSS_HIDL_1_0_TARGET_LIST += msm8610 GNSS_HIDL_1_0_TARGET_LIST += apq8084 GNSS_HIDL_1_0_TARGET_LIST += msm8916 GNSS_HIDL_1_0_TARGET_LIST += msm8994 -GNSS_HIDL_1_0_TARGET_LIST += msm8909 +GNSS_HIDL_2_0_TARGET_LIST := msm8909 GNSS_HIDL_1_0_TARGET_LIST += msm8952 GNSS_HIDL_1_0_TARGET_LIST += msm8992 GNSS_HIDL_1_0_TARGET_LIST += msm8996 -GNSS_HIDL_2_0_TARGET_LIST := msm8937 +GNSS_HIDL_2_0_TARGET_LIST += msm8937 GNSS_HIDL_2_0_TARGET_LIST += msm8953 GNSS_HIDL_2_0_TARGET_LIST += msm8998 GNSS_HIDL_2_0_TARGET_LIST += apq8098_latv diff --git a/gps/core/ContextBase.cpp b/gps/core/ContextBase.cpp index 8e568eae..d12f5530 100644 --- a/gps/core/ContextBase.cpp +++ b/gps/core/ContextBase.cpp @@ -92,6 +92,7 @@ const loc_param_s_type ContextBase::mGps_conf_table[] = {"CUSTOM_NMEA_GGA_FIX_QUALITY_ENABLED", &mGps_conf.CUSTOM_NMEA_GGA_FIX_QUALITY_ENABLED, NULL, 'n'}, {"NI_SUPL_DENY_ON_NFW_LOCKED", &mGps_conf.NI_SUPL_DENY_ON_NFW_LOCKED, NULL, 'n'}, + {"ENABLE_NMEA_PRINT", &mGps_conf.ENABLE_NMEA_PRINT, NULL, 'n'} }; const loc_param_s_type ContextBase::mSap_conf_table[] = @@ -193,6 +194,8 @@ void ContextBase::readConfig() mGps_conf.CUSTOM_NMEA_GGA_FIX_QUALITY_ENABLED = 0; /* default configuration for NI_SUPL_DENY_ON_NFW_LOCKED */ mGps_conf.NI_SUPL_DENY_ON_NFW_LOCKED = 1; + /* By default NMEA Printing is disabled */ + mGps_conf.ENABLE_NMEA_PRINT = 0; UTIL_READ_CONF(LOC_PATH_GPS_CONF, mGps_conf_table); UTIL_READ_CONF(LOC_PATH_SAP_CONF, mSap_conf_table); diff --git a/gps/core/ContextBase.h b/gps/core/ContextBase.h index e63450ff..1a003c86 100644 --- a/gps/core/ContextBase.h +++ b/gps/core/ContextBase.h @@ -1,4 +1,4 @@ -/* Copyright (c) 2011-2017, The Linux Foundation. All rights reserved. +/* Copyright (c) 2011-2017, 2020, The Linux Foundation. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are @@ -76,6 +76,7 @@ typedef struct loc_gps_cfg_s uint32_t GNSS_DEPLOYMENT; uint32_t CUSTOM_NMEA_GGA_FIX_QUALITY_ENABLED; uint32_t NI_SUPL_DENY_ON_NFW_LOCKED; + uint32_t ENABLE_NMEA_PRINT; } loc_gps_cfg_s_type; /* NOTE: the implementaiton of the parser casts number diff --git a/gps/core/loc_core_log.cpp b/gps/core/loc_core_log.cpp index ddf18ec8..904f94bb 100644 --- a/gps/core/loc_core_log.cpp +++ b/gps/core/loc_core_log.cpp @@ -1,4 +1,4 @@ -/* Copyright (c) 2011-2015, The Linux Foundation. All rights reserved. +/* Copyright (c) 2011-2015, 2020 The Linux Foundation. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are @@ -53,7 +53,7 @@ void LocPosMode::logv() const } /* GPS status names */ -static const loc_name_val_s_type gps_status_name[] = +DECLARE_TBL(gps_status_name) = { NAME_VAL( LOC_GPS_STATUS_NONE ), NAME_VAL( LOC_GPS_STATUS_SESSION_BEGIN ), @@ -61,18 +61,16 @@ static const loc_name_val_s_type gps_status_name[] = NAME_VAL( LOC_GPS_STATUS_ENGINE_ON ), NAME_VAL( LOC_GPS_STATUS_ENGINE_OFF ), }; -static const int gps_status_num = sizeof(gps_status_name) / sizeof(loc_name_val_s_type); /* Find Android GPS status name */ const char* loc_get_gps_status_name(LocGpsStatusValue gps_status) { - return loc_get_name_from_val(gps_status_name, gps_status_num, - (long) gps_status); + return loc_get_name_from_val(gps_status_name_tbl, (int64_t) gps_status); } -static const loc_name_val_s_type loc_eng_position_modes[] = +DECLARE_TBL(loc_eng_position_modes) = { NAME_VAL( LOC_POSITION_MODE_STANDALONE ), NAME_VAL( LOC_POSITION_MODE_MS_BASED ), @@ -83,25 +81,23 @@ static const loc_name_val_s_type loc_eng_position_modes[] = NAME_VAL( LOC_POSITION_MODE_RESERVED_4 ), NAME_VAL( LOC_POSITION_MODE_RESERVED_5 ) }; -static const int loc_eng_position_mode_num = sizeof(loc_eng_position_modes) / sizeof(loc_name_val_s_type); const char* loc_get_position_mode_name(LocGpsPositionMode mode) { - return loc_get_name_from_val(loc_eng_position_modes, loc_eng_position_mode_num, (long) mode); + return loc_get_name_from_val(loc_eng_position_modes_tbl, (int64_t) mode); } -static const loc_name_val_s_type loc_eng_position_recurrences[] = +DECLARE_TBL(loc_eng_position_recurrences) = { NAME_VAL( LOC_GPS_POSITION_RECURRENCE_PERIODIC ), NAME_VAL( LOC_GPS_POSITION_RECURRENCE_SINGLE ) }; -static const int loc_eng_position_recurrence_num = sizeof(loc_eng_position_recurrences) / sizeof(loc_name_val_s_type); const char* loc_get_position_recurrence_name(LocGpsPositionRecurrence recur) { - return loc_get_name_from_val(loc_eng_position_recurrences, loc_eng_position_recurrence_num, (long) recur); + return loc_get_name_from_val(loc_eng_position_recurrences_tbl, (int64_t) recur); } const char* loc_get_aiding_data_mask_names(LocGpsAidingData /*data*/) @@ -110,7 +106,7 @@ const char* loc_get_aiding_data_mask_names(LocGpsAidingData /*data*/) } -static const loc_name_val_s_type loc_eng_agps_types[] = +DECLARE_TBL(loc_eng_agps_types) = { NAME_VAL( LOC_AGPS_TYPE_INVALID ), NAME_VAL( LOC_AGPS_TYPE_ANY ), @@ -118,44 +114,41 @@ static const loc_name_val_s_type loc_eng_agps_types[] = NAME_VAL( LOC_AGPS_TYPE_C2K ), NAME_VAL( LOC_AGPS_TYPE_WWAN_ANY ) }; -static const int loc_eng_agps_type_num = sizeof(loc_eng_agps_types) / sizeof(loc_name_val_s_type); const char* loc_get_agps_type_name(LocAGpsType type) { - return loc_get_name_from_val(loc_eng_agps_types, loc_eng_agps_type_num, (long) type); + return loc_get_name_from_val(loc_eng_agps_types_tbl, (int64_t) type); } -static const loc_name_val_s_type loc_eng_ni_types[] = +DECLARE_TBL(loc_eng_ni_types) = { NAME_VAL( LOC_GPS_NI_TYPE_VOICE ), NAME_VAL( LOC_GPS_NI_TYPE_UMTS_SUPL ), NAME_VAL( LOC_GPS_NI_TYPE_UMTS_CTRL_PLANE ), NAME_VAL( LOC_GPS_NI_TYPE_EMERGENCY_SUPL ) }; -static const int loc_eng_ni_type_num = sizeof(loc_eng_ni_types) / sizeof(loc_name_val_s_type); const char* loc_get_ni_type_name(LocGpsNiType type) { - return loc_get_name_from_val(loc_eng_ni_types, loc_eng_ni_type_num, (long) type); + return loc_get_name_from_val(loc_eng_ni_types_tbl, (int64_t) type); } -static const loc_name_val_s_type loc_eng_ni_responses[] = +DECLARE_TBL(loc_eng_ni_responses) = { NAME_VAL( LOC_GPS_NI_RESPONSE_ACCEPT ), NAME_VAL( LOC_GPS_NI_RESPONSE_DENY ), NAME_VAL( LOC_GPS_NI_RESPONSE_DENY ) }; -static const int loc_eng_ni_reponse_num = sizeof(loc_eng_ni_responses) / sizeof(loc_name_val_s_type); const char* loc_get_ni_response_name(LocGpsUserResponseType response) { - return loc_get_name_from_val(loc_eng_ni_responses, loc_eng_ni_reponse_num, (long) response); + return loc_get_name_from_val(loc_eng_ni_responses_tbl, (int64_t) response); } -static const loc_name_val_s_type loc_eng_ni_encodings[] = +DECLARE_TBL(loc_eng_ni_encodings) = { NAME_VAL( LOC_GPS_ENC_NONE ), NAME_VAL( LOC_GPS_ENC_SUPL_GSM_DEFAULT ), @@ -163,55 +156,51 @@ static const loc_name_val_s_type loc_eng_ni_encodings[] = NAME_VAL( LOC_GPS_ENC_SUPL_UCS2 ), NAME_VAL( LOC_GPS_ENC_UNKNOWN ) }; -static const int loc_eng_ni_encoding_num = sizeof(loc_eng_ni_encodings) / sizeof(loc_name_val_s_type); const char* loc_get_ni_encoding_name(LocGpsNiEncodingType encoding) { - return loc_get_name_from_val(loc_eng_ni_encodings, loc_eng_ni_encoding_num, (long) encoding); + return loc_get_name_from_val(loc_eng_ni_encodings_tbl, (int64_t) encoding); } -static const loc_name_val_s_type loc_eng_agps_bears[] = +DECLARE_TBL(loc_eng_agps_bears) = { NAME_VAL( AGPS_APN_BEARER_INVALID ), NAME_VAL( AGPS_APN_BEARER_IPV4 ), NAME_VAL( AGPS_APN_BEARER_IPV6 ), NAME_VAL( AGPS_APN_BEARER_IPV4V6 ) }; -static const int loc_eng_agps_bears_num = sizeof(loc_eng_agps_bears) / sizeof(loc_name_val_s_type); const char* loc_get_agps_bear_name(AGpsBearerType bearer) { - return loc_get_name_from_val(loc_eng_agps_bears, loc_eng_agps_bears_num, (long) bearer); + return loc_get_name_from_val(loc_eng_agps_bears_tbl, (int64_t) bearer); } -static const loc_name_val_s_type loc_eng_server_types[] = +DECLARE_TBL(loc_eng_server_types) = { NAME_VAL( LOC_AGPS_CDMA_PDE_SERVER ), NAME_VAL( LOC_AGPS_CUSTOM_PDE_SERVER ), NAME_VAL( LOC_AGPS_MPC_SERVER ), NAME_VAL( LOC_AGPS_SUPL_SERVER ) }; -static const int loc_eng_server_types_num = sizeof(loc_eng_server_types) / sizeof(loc_name_val_s_type); const char* loc_get_server_type_name(LocServerType type) { - return loc_get_name_from_val(loc_eng_server_types, loc_eng_server_types_num, (long) type); + return loc_get_name_from_val(loc_eng_server_types_tbl, (int64_t) type); } -static const loc_name_val_s_type loc_eng_position_sess_status_types[] = +DECLARE_TBL(loc_eng_position_sess_status_types) = { NAME_VAL( LOC_SESS_SUCCESS ), NAME_VAL( LOC_SESS_INTERMEDIATE ), NAME_VAL( LOC_SESS_FAILURE ) }; -static const int loc_eng_position_sess_status_num = sizeof(loc_eng_position_sess_status_types) / sizeof(loc_name_val_s_type); const char* loc_get_position_sess_status_name(enum loc_sess_status status) { - return loc_get_name_from_val(loc_eng_position_sess_status_types, loc_eng_position_sess_status_num, (long) status); + return loc_get_name_from_val(loc_eng_position_sess_status_types_tbl, (int64_t) status); } -static const loc_name_val_s_type loc_eng_agps_status_names[] = +DECLARE_TBL(loc_eng_agps_status_names) = { NAME_VAL( LOC_GPS_REQUEST_AGPS_DATA_CONN ), NAME_VAL( LOC_GPS_RELEASE_AGPS_DATA_CONN ), @@ -219,9 +208,8 @@ static const loc_name_val_s_type loc_eng_agps_status_names[] = NAME_VAL( LOC_GPS_AGPS_DATA_CONN_DONE ), NAME_VAL( LOC_GPS_AGPS_DATA_CONN_FAILED ) }; -static const int loc_eng_agps_status_num = sizeof(loc_eng_agps_status_names) / sizeof(loc_name_val_s_type); const char* loc_get_agps_status_name(LocAGpsStatusValue status) { - return loc_get_name_from_val(loc_eng_agps_status_names, loc_eng_agps_status_num, (long) status); + return loc_get_name_from_val(loc_eng_agps_status_names_tbl, (int64_t) status); } diff --git a/gps/etc/Android.mk b/gps/etc/Android.mk new file mode 100644 index 00000000..22ca2f71 --- /dev/null +++ b/gps/etc/Android.mk @@ -0,0 +1,21 @@ + +LOCAL_PATH := $(call my-dir) + +include $(CLEAR_VARS) +LOCAL_MODULE := gps.conf +LOCAL_VENDOR_MODULE := true +LOCAL_MODULE_TAGS := optional +LOCAL_MODULE_CLASS := ETC +LOCAL_SRC_FILES := gps.conf +LOCAL_MODULE_PATH := $(TARGET_OUT_VENDOR_ETC) +include $(BUILD_PREBUILT) + +include $(CLEAR_VARS) +LOCAL_MODULE := flp.conf +LOCAL_VENDOR_MODULE := true +LOCAL_MODULE_TAGS := optional +LOCAL_MODULE_CLASS := ETC +LOCAL_SRC_FILES := flp.conf +LOCAL_MODULE_PATH := $(TARGET_OUT_VENDOR_ETC) +include $(BUILD_PREBUILT) + diff --git a/gps/etc/flp.conf b/gps/etc/flp.conf index d28e20d4..65d54d38 100644 --- a/gps/etc/flp.conf +++ b/gps/etc/flp.conf @@ -36,14 +36,6 @@ OUTDOOR_TRIP_BATCH_SIZE=600 # defaults to 20 seconds by the modem. # BATCH_SESSION_TIMEOUT=20000 -################################### -# FLP CAPABILITIES BIT MASK -################################### -# GEOFENCE = 0x01 -# BATCHING = 0x02 -# default = GEOFENCE | BATCHING -CAPABILITIES=0x03 - ################################### # FLP BATCHING ACCURACY ################################### @@ -57,32 +49,6 @@ CAPABILITIES=0x03 # High accuracy = 2 ACCURACY=1 -################################### -# FLP GEOFENCE RESPONSIVENESS -################################### -# If set to one of the defined values below, -# it will override the responsiveness for -# FLP geofence, which implements the fused -# location API. If not set to a value defined -# below, which is default, it will not -# override the responsivness. -# FLP_GEOFENCE_RESPONSIVENESS_OVERRIDE Values: -# 1: LOW responsiveness -# 2: MEDIUM responsiveness -# 3: HIGH responsiveness -FLP_GEOFENCE_RESPONSIVENESS_OVERRIDE = 0 - -#################################### -# By default APPS must support LB only if modem support -# LB 1.5 and above. This parameter adds an exception -# for targets where modem only supports LB 1.0. -# This might be useful for primarily outdoor devices. -# 0: MUST NOT ALLOW LB IF MODEM ONLY SUPPORTS -# LB 1.0 -# 1: ALLOW LB IF MODEM ONLY SUPPORTS LB 1.0 -#################################### -ALLOW_LB_1_0 = 0 - #################################### # By default if network fixes are not sensor assisted # these fixes must be dropped. This parameter adds an exception diff --git a/gps/etc/gps.conf b/gps/etc/gps.conf index 81104c58..78e5d849 100644 --- a/gps/etc/gps.conf +++ b/gps/etc/gps.conf @@ -1,9 +1,3 @@ -#Uncommenting these urls would only enable -#the power up auto injection and force injection(test case). -#XTRA_SERVER_1=http://xtrapath1.izatcloud.net/xtra2.bin -#XTRA_SERVER_2=http://xtrapath2.izatcloud.net/xtra2.bin -#XTRA_SERVER_3=http://xtrapath3.izatcloud.net/xtra2.bin - #Version check for XTRA #DISABLE = 0 #AUTO = 1 @@ -30,18 +24,11 @@ DEBUG_LEVEL = 3 # Intermediate position report, 1=enable, 0=disable INTERMEDIATE_POS=0 -# Below bit mask configures how GPS functionalities -# should be locked when user turns off GPS on Settings -# Set bit 0x1 if MO GPS functionalities are to be locked -# Set bit 0x2 if NI GPS functionalities are to be locked -# default - non is locked for backward compatibility -#GPS_LOCK = 0 - # supl version 1.0 SUPL_VER=0x10000 # Emergency SUPL, 1=enable, 0=disable -#SUPL_ES=0 +#SUPL_ES=1 #Choose PDN for Emergency SUPL #1 - Use emergency PDN @@ -60,9 +47,8 @@ SUPL_VER=0x10000 # MSB = 0x02 # MSA = 0x04 # ON_DEMAND_TIME = 0x10 -# GEOFENCE = 0x20 -# default = ON_DEMAND_TIME | MSA | MSB | SCHEDULING | GEOFENCE -CAPABILITIES=0x37 +# default = ON_DEMAND_TIME | MSA | MSB | SCHEDULING +CAPABILITIES=0x17 # Accuracy threshold for intermediate positions # less accurate positions are ignored, 0 for passing all positions @@ -156,7 +142,7 @@ A_GLONASS_POS_PROTOCOL_SELECT = 0 # 0x2: WLAN AP Measurements for LPPe CP # 0x4: SRN AP measurement for CP # 0x8: Sensor Barometer Measurement LPPe CP -LPPE_CP_TECHNOLOGY = 0 +#LPPE_CP_TECHNOLOGY = 0 ################################################## # Select technology for LPPe User Plane @@ -165,7 +151,7 @@ LPPE_CP_TECHNOLOGY = 0 # 0x2: WLAN AP Measurements for LPPe UP # 0x4: SRN AP measurement for UP # 0x8: Sensor Barometer Measurement LPPe UP -LPPE_UP_TECHNOLOGY = 0 +#LPPE_UP_TECHNOLOGY = 0 ################################################## # AGPS_CONFIG_INJECT @@ -310,7 +296,7 @@ MODEM_TYPE = 1 # 1 : enabled # This setting enables GPS engine to estimate clock # bias and drift when the signal from at least 1 -# SV is available and the UE's position is known by +# SV is available and the UE’s position is known by # other position engines. #POSITION_ASSISTED_CLOCK_ESTIMATOR_ENABLED = 0 @@ -332,8 +318,9 @@ CP_MTLR_ES=0 ################################################## # 0 : Enable QTI GNSS (default) # 1 : Enable QCSR SS5 -# This setting use to select between QTI GNSS -# and QCSR SS5 hardware receiver. +# 2 : Enable PDS API +# This setting use to select between QTI GNSS, +# QCSR SS5 hardware receiver, and PDS API. # By default QTI GNSS receiver is enabled. # GNSS_DEPLOYMENT = 0 diff --git a/gps/gnss/GnssAdapter.cpp b/gps/gnss/GnssAdapter.cpp index 85d51f62..cf48d917 100644 --- a/gps/gnss/GnssAdapter.cpp +++ b/gps/gnss/GnssAdapter.cpp @@ -3434,9 +3434,9 @@ GnssAdapter::needReportForGnssClient(const UlpLocation& ulpLocation, bool GnssAdapter::needReportForFlpClient(enum loc_sess_status status, LocPosTechMask techMask) { - if ((status == LOC_SESS_INTERMEDIATE) && - !(techMask & LOC_POS_TECH_MASK_SENSORS) && - (!getAllowFlpNetworkFixes())) { + if (((LOC_SESS_INTERMEDIATE == status) && !(techMask & LOC_POS_TECH_MASK_SENSORS) && + (!getAllowFlpNetworkFixes())) || + (LOC_SESS_FAILURE == status)) { return false; } else { return true; @@ -3611,7 +3611,7 @@ void GnssAdapter::reportSv(GnssSvNotification& svNotify) { int numSv = svNotify.count; - int16_t gnssSvId = 0; + uint16_t gnssSvId = 0; uint64_t svUsedIdMask = 0; for (int i=0; i < numSv; i++) { svUsedIdMask = 0; @@ -3655,6 +3655,9 @@ GnssAdapter::reportSv(GnssSvNotification& svNotify) svUsedIdMask = mGnssSvIdUsedInPosition.glo_sv_used_ids_mask; } } + // map the svid to respective constellation range 1..xx + // then repective constellation svUsedIdMask map correctly to svid + gnssSvId = gnssSvId - GLO_SV_PRN_MIN + 1; break; case GNSS_SV_TYPE_BEIDOU: if (mGnssSvIdUsedInPosAvail) { @@ -3680,6 +3683,7 @@ GnssAdapter::reportSv(GnssSvNotification& svNotify) svUsedIdMask = mGnssSvIdUsedInPosition.bds_sv_used_ids_mask; } } + gnssSvId = gnssSvId - BDS_SV_PRN_MIN + 1; break; case GNSS_SV_TYPE_GALILEO: if (mGnssSvIdUsedInPosAvail) { @@ -3699,6 +3703,7 @@ GnssAdapter::reportSv(GnssSvNotification& svNotify) svUsedIdMask = mGnssSvIdUsedInPosition.gal_sv_used_ids_mask; } } + gnssSvId = gnssSvId - GAL_SV_PRN_MIN + 1; break; case GNSS_SV_TYPE_QZSS: if (mGnssSvIdUsedInPosAvail) { @@ -3721,11 +3726,13 @@ GnssAdapter::reportSv(GnssSvNotification& svNotify) svUsedIdMask = mGnssSvIdUsedInPosition.qzss_sv_used_ids_mask; } } + gnssSvId = gnssSvId - QZSS_SV_PRN_MIN + 1; break; case GNSS_SV_TYPE_NAVIC: if (mGnssSvIdUsedInPosAvail) { svUsedIdMask = mGnssSvIdUsedInPosition.navic_sv_used_ids_mask; } + gnssSvId = gnssSvId - NAVIC_SV_PRN_MIN + 1; break; default: svUsedIdMask = 0; @@ -3734,7 +3741,7 @@ GnssAdapter::reportSv(GnssSvNotification& svNotify) // If SV ID was used in previous position fix, then set USED_IN_FIX // flag, else clear the USED_IN_FIX flag. - if ((gnssSvId < 64) && (svUsedIdMask & (1ULL << (gnssSvId - 1)))) { + if (svFitsMask(svUsedIdMask, gnssSvId) && (svUsedIdMask & (1ULL << (gnssSvId - 1)))) { svNotify.gnssSvs[i].gnssSvOptionsMask |= GNSS_SV_OPTIONS_USED_IN_FIX_BIT; } } @@ -3758,6 +3765,7 @@ GnssAdapter::reportSv(GnssSvNotification& svNotify) } mGnssSvIdUsedInPosAvail = false; + mGnssMbSvIdUsedInPosAvail = false; } void @@ -3824,6 +3832,10 @@ GnssAdapter::reportNmea(const char* nmea, size_t length) it->second.gnssNmeaCb(nmeaNotification); } } + + if (isNMEAPrintEnabled()) { + LOC_LOGd("[%" PRId64 ", %zu] %s", now, length, nmea); + } } void diff --git a/gps/gnss/GnssAdapter.h b/gps/gnss/GnssAdapter.h index b197247f..48db26b5 100644 --- a/gps/gnss/GnssAdapter.h +++ b/gps/gnss/GnssAdapter.h @@ -46,6 +46,7 @@ #define LOC_NI_NO_RESPONSE_TIME 20 #define LOC_GPS_NI_RESPONSE_IGNORE 4 #define ODCPI_EXPECTED_INJECTION_TIME_MS 10000 +#define IS_SS5_HW_ENABLED (1) class GnssAdapter; @@ -305,6 +306,8 @@ public: void resetSvConfig(uint32_t sessionId); void configLeverArm(uint32_t sessionId, const LeverArmConfigInfo& configInfo); void configRobustLocation(uint32_t sessionId, bool enable, bool enableForE911); + inline bool isSS5HWEnabled() + { return ((mContext != NULL) && (IS_SS5_HW_ENABLED == mContext->mGps_conf.GNSS_DEPLOYMENT)); } /* ==== NI ============================================================================= */ /* ======== COMMANDS ====(Called from Client Thread)==================================== */ @@ -521,6 +524,10 @@ public: void notifyClientOfCachedLocationSystemInfo(LocationAPI* client, const LocationCallbacks& callbacks); void updateSystemPowerStateCommand(PowerStateType systemPowerState); + inline bool isNMEAPrintEnabled() { + return (((mContext != NULL) && (0 != mContext->mGps_conf.ENABLE_NMEA_PRINT)) ? + (true) : (false)); + } }; #endif //GNSS_ADAPTER_H diff --git a/gps/gnss/location_gnss.cpp b/gps/gnss/location_gnss.cpp index 50e8872f..4c2120a4 100644 --- a/gps/gnss/location_gnss.cpp +++ b/gps/gnss/location_gnss.cpp @@ -88,6 +88,7 @@ static uint32_t gnssUpdateSvConfig(const GnssSvTypeConfig& svTypeConfig, static uint32_t gnssResetSvConfig(); static uint32_t configLeverArm(const LeverArmConfigInfo& configInfo); static uint32_t configRobustLocation(bool enable, bool enableForE911); +static bool isSS5HWEnabled(); static const GnssInterface gGnssInterface = { sizeof(GnssInterface), @@ -134,6 +135,7 @@ static const GnssInterface gGnssInterface = { gnssResetSvConfig, configLeverArm, configRobustLocation, + isSS5HWEnabled, }; #ifndef DEBUG_X86 @@ -457,6 +459,13 @@ static uint32_t configLeverArm(const LeverArmConfigInfo& configInfo){ } } +static bool isSS5HWEnabled() { + if (NULL != gGnssAdapter) { + return gGnssAdapter->isSS5HWEnabled(); + } + return false; +} + static uint32_t configRobustLocation(bool enable, bool enableForE911){ if (NULL != gGnssAdapter) { return gGnssAdapter->configRobustLocationCommand(enable, enableForE911); diff --git a/gps/location/LocationAPI.cpp b/gps/location/LocationAPI.cpp index dd0b002f..c591223c 100644 --- a/gps/location/LocationAPI.cpp +++ b/gps/location/LocationAPI.cpp @@ -119,9 +119,11 @@ void LocationAPI::onRemoveClientCompleteCb (LocationAdapterTypeMask adapterType) } pthread_mutex_unlock(&gDataMutex); - if ((true == invokeCallback) && (nullptr != destroyCompleteCb)) { + if (invokeCallback) { LOC_LOGd("invoke client destroy cb"); - (destroyCompleteCb) (); + if (!destroyCompleteCb) { + (destroyCompleteCb) (); + } delete this; } @@ -273,7 +275,7 @@ LocationAPI::destroy(locationApiDestroyCompleteCallback destroyCompleteCb) gData.clientData.erase(it); - if ((NULL != destroyCompleteCb) && (false == needToWait)) { + if (!needToWait) { invokeDestroyCb = true; } } else { @@ -282,8 +284,10 @@ LocationAPI::destroy(locationApiDestroyCompleteCallback destroyCompleteCb) } pthread_mutex_unlock(&gDataMutex); - if (invokeDestroyCb == true) { - (destroyCompleteCb) (); + if (invokeDestroyCb) { + if (!destroyCompleteCb) { + (destroyCompleteCb) (); + } delete this; } } diff --git a/gps/location/LocationAPIClientBase.cpp b/gps/location/LocationAPIClientBase.cpp index 5a09712e..c2416607 100644 --- a/gps/location/LocationAPIClientBase.cpp +++ b/gps/location/LocationAPIClientBase.cpp @@ -1,4 +1,4 @@ -/* Copyright (c) 2017 The Linux Foundation. All rights reserved. +/* Copyright (c) 2017-2020 The Linux Foundation. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are @@ -310,25 +310,43 @@ void LocationAPIClientBase::locAPISetCallbacks(LocationCallbacks& locationCallba pthread_mutex_unlock(&mMutex); } -LocationAPIClientBase::~LocationAPIClientBase() +void LocationAPIClientBase::destroy() { + LOC_LOGD("LocationAPIClientBase::destroy()"); + pthread_mutex_lock(&mMutex); mGeofenceBreachCallback = nullptr; - if (mLocationAPI) { - mLocationAPI->destroy(); - mLocationAPI = nullptr; - } - for (int i = 0; i < REQUEST_MAX; i++) { mRequestQueues[i].reset((uint32_t)0); } + LocationAPI* localHandle = nullptr; + if (nullptr != mLocationAPI) { + localHandle = mLocationAPI; + mLocationAPI = nullptr; + } + pthread_mutex_unlock(&mMutex); + // Invoking destroy has the possibility of destroy complete callback + // being invoked right away in the same context, hence no instance + // member must be accessed after the destroy call. + if (nullptr != localHandle) { + localHandle->destroy([this]() {onLocationApiDestroyCompleteCb();}); + } +} + +LocationAPIClientBase::~LocationAPIClientBase() +{ pthread_mutex_destroy(&mMutex); } +void LocationAPIClientBase::onLocationApiDestroyCompleteCb() +{ + LOC_LOGD("LocationAPIClientBase::onLocationApiDestroyCompleteCb()"); + delete this; +} uint32_t LocationAPIClientBase::locAPIStartTracking(TrackingOptions& options) { @@ -378,11 +396,12 @@ void LocationAPIClientBase::locAPIUpdateTrackingOptions(TrackingOptions& options if (mLocationAPI) { uint32_t session = 0; session = mRequestQueues[REQUEST_TRACKING].getSession(); - if (session > 0) { + // Not allowing to update the tracking options for stopped session + if (session > 0 && mTracking) { mRequestQueues[REQUEST_TRACKING].push(new UpdateTrackingOptionsRequest(*this)); mLocationAPI->updateTrackingOptions(session, options); } else { - LOC_LOGE("%s:%d] invalid session: %d.", __FUNCTION__, __LINE__, session); + LOC_LOGe("invalid or stopped session: %d.", session); } } pthread_mutex_unlock(&mMutex); diff --git a/gps/location/LocationAPIClientBase.h b/gps/location/LocationAPIClientBase.h index 098000c5..591775af 100644 --- a/gps/location/LocationAPIClientBase.h +++ b/gps/location/LocationAPIClientBase.h @@ -1,4 +1,4 @@ -/* Copyright (c) 2017-2019 The Linux Foundation. All rights reserved. +/* Copyright (c) 2017-2020 The Linux Foundation. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are @@ -200,10 +200,12 @@ private: class LocationAPIClientBase { public: LocationAPIClientBase(); - virtual ~LocationAPIClientBase(); LocationAPIClientBase(const LocationAPIClientBase&) = delete; LocationAPIClientBase& operator=(const LocationAPIClientBase&) = delete; + void destroy(); + void onLocationApiDestroyCompleteCb(); + void locAPISetCallbacks(LocationCallbacks& locationCallbacks); void removeSession(uint32_t session); LocationAPIRequest* getRequestBySession(uint32_t session); @@ -283,6 +285,9 @@ public: inline virtual void onLocationSystemInfoCb(LocationSystemInfo /*locationSystemInfo*/) {} +protected: + virtual ~LocationAPIClientBase(); + private: // private inner classes typedef struct { @@ -421,10 +426,10 @@ private: public: StopTrackingRequest(LocationAPIClientBase& API) : mAPI(API) {} inline void onResponse(LocationError error, uint32_t id) { - mAPI.onStopTrackingCb(error); if (error == LOCATION_ERROR_SUCCESS) { mAPI.removeSession(id); } + mAPI.onStopTrackingCb(error); } LocationAPIClientBase& mAPI; }; diff --git a/gps/location/location_interface.h b/gps/location/location_interface.h index 4eb0549e..019bf09f 100644 --- a/gps/location/location_interface.h +++ b/gps/location/location_interface.h @@ -96,6 +96,7 @@ struct GnssInterface { uint32_t (*gnssResetSvConfig)(); uint32_t (*configLeverArm)(const LeverArmConfigInfo& configInfo); uint32_t (*configRobustLocation)(bool enable, bool enableForE911); + bool (*isSS5HWEnabled)(); }; struct BatchingInterface { diff --git a/gps/utils/gps_extended_c.h b/gps/utils/gps_extended_c.h index 8eb11523..fcda385f 100644 --- a/gps/utils/gps_extended_c.h +++ b/gps/utils/gps_extended_c.h @@ -468,6 +468,13 @@ typedef uint32_t GnssAdditionalSystemInfoMask; #define NAVIC_SV_PRN_MIN 401 #define NAVIC_SV_PRN_MAX 414 +/* Checking svIdOneBase can be set to the corresponding bit in mask */ +#define svFitsMask(mask, svIdOneBase) \ + ((svIdOneBase) >= 1 && (svIdOneBase) <= (sizeof(mask) << 3)) +/* Setting svIdOneBase specific bit in the mask if the bit offset fits */ +#define setSvMask(mask, svIdOneBase) \ + if (svFitsMask(mask, svIdOneBase)) mask |= (1ULL << ((svIdOneBase) - 1)) + typedef enum { LOC_RELIABILITY_NOT_SET = 0, LOC_RELIABILITY_VERY_LOW = 1, diff --git a/gps/utils/loc_cfg.cpp b/gps/utils/loc_cfg.cpp index 5f15ad1f..db0225be 100644 --- a/gps/utils/loc_cfg.cpp +++ b/gps/utils/loc_cfg.cpp @@ -617,14 +617,18 @@ int loc_read_process_conf(const char* conf_file_name, uint32_t * process_count_p UTIL_READ_CONF(conf_file_name, loc_feature_conf_table); //Set service mask for GTP_MODE - if(strcmp(conf.feature_gtp_mode, "DISABLED") == 0) { + if (strcmp(conf.feature_gtp_mode, "DISABLED") == 0) { LOC_LOGD("%s:%d]: GTP MODE DISABLED", __func__, __LINE__); } - else if(strcmp(conf.feature_gtp_mode, "LEGACY_WWAN") == 0) { + else if (strcmp(conf.feature_gtp_mode, "LEGACY_WWAN") == 0) { LOC_LOGD("%s:%d]: Setting GTP MODE to mode: LEGACY_WWAN", __func__, __LINE__); loc_service_mask |= LOC_FEATURE_MASK_GTP_MODEM_CELL_BASIC; } - else if(strcmp(conf.feature_gtp_mode, "SDK") == 0) { + else if (strcmp(conf.feature_gtp_mode, "SDK") == 0) { + LOC_LOGD("%s:%d]: Setting GTP MODE to mode: SDK", __func__, __LINE__); + loc_service_mask |= LOC_FEATURE_MASK_GTP_WIFI_BASIC; + } + else if (strcmp(conf.feature_gtp_mode, "SDK_WIFI") == 0) { LOC_LOGD("%s:%d]: Setting GTP MODE to mode: SDK", __func__, __LINE__); loc_service_mask |= LOC_FEATURE_MASK_GTP_WIFI_BASIC; } @@ -634,11 +638,11 @@ int loc_read_process_conf(const char* conf_file_name, uint32_t * process_count_p " Setting GTP WIFI to default mode: DISABLED", __func__, __LINE__); } //Set service mask for GTP_WAA - if(strcmp(conf.feature_gtp_waa, "BASIC") == 0) { + if (strcmp(conf.feature_gtp_waa, "BASIC") == 0) { LOC_LOGD("%s:%d]: Setting GTP WAA to mode: BASIC", __func__, __LINE__); loc_service_mask |= LOC_FEATURE_MASK_GTP_WAA_BASIC; } - else if(strcmp(conf.feature_gtp_waa, "DISABLED") == 0) { + else if (strcmp(conf.feature_gtp_waa, "DISABLED") == 0) { LOC_LOGD("%s:%d]: GTP WAA DISABLED", __func__, __LINE__); } //conf file has a garbage value @@ -648,18 +652,18 @@ int loc_read_process_conf(const char* conf_file_name, uint32_t * process_count_p } //Set service mask for SAP - if(strcmp(conf.feature_sap, "PREMIUM") == 0) { + if (strcmp(conf.feature_sap, "PREMIUM") == 0) { LOC_LOGD("%s:%d]: Setting SAP to mode: PREMIUM", __func__, __LINE__); loc_service_mask |= LOC_FEATURE_MASK_SAP_PREMIUM; } - else if(strcmp(conf.feature_sap, "BASIC") == 0) { + else if (strcmp(conf.feature_sap, "BASIC") == 0) { LOC_LOGD("%s:%d]: Setting SAP to mode: BASIC", __func__, __LINE__); loc_service_mask |= LOC_FEATURE_MASK_SAP_BASIC; } - else if(strcmp(conf.feature_sap, "MODEM_DEFAULT") == 0) { + else if (strcmp(conf.feature_sap, "MODEM_DEFAULT") == 0) { LOC_LOGD("%s:%d]: Setting SAP to mode: MODEM_DEFAULT", __func__, __LINE__); } - else if(strcmp(conf.feature_sap, "DISABLED") == 0) { + else if (strcmp(conf.feature_sap, "DISABLED") == 0) { LOC_LOGD("%s:%d]: Setting SAP to mode: DISABLED", __func__, __LINE__); } else { @@ -669,56 +673,56 @@ int loc_read_process_conf(const char* conf_file_name, uint32_t * process_count_p } // Set service mask for ODCPI - if(strcmp(conf.feature_odcpi, "BASIC") == 0) { + if (strcmp(conf.feature_odcpi, "BASIC") == 0) { LOC_LOGD("%s:%d]: Setting ODCPI to mode: BASIC", __func__, __LINE__); loc_service_mask |= LOC_FEATURE_MASK_ODCPI; } - else if(strcmp(conf.feature_odcpi, "DISABLED") == 0) { + else if (strcmp(conf.feature_odcpi, "DISABLED") == 0) { LOC_LOGD("%s:%d]: Setting ODCPI to mode: DISABLED", __func__, __LINE__); } - else if(strcmp(conf.feature_odcpi, "PREMIUM") == 0) { + else if (strcmp(conf.feature_odcpi, "PREMIUM") == 0) { LOC_LOGD("%s:%d]: Unrecognized value for ODCPI mode."\ "Setting ODCPI to default mode: BASIC", __func__, __LINE__); loc_service_mask |= LOC_FEATURE_MASK_ODCPI; } // Set service mask for FREE_WIFI_SCAN_INJECT - if(strcmp(conf.feature_free_wifi_scan_inject, "BASIC") == 0) { + if (strcmp(conf.feature_free_wifi_scan_inject, "BASIC") == 0) { LOC_LOGD("%s:%d]: Setting FREE_WIFI_SCAN_INJECT to mode: BASIC", __func__, __LINE__); loc_service_mask |= LOC_FEATURE_MASK_FREE_WIFI_SCAN_INJECT; } - else if(strcmp(conf.feature_free_wifi_scan_inject, "DISABLED") == 0) { + else if (strcmp(conf.feature_free_wifi_scan_inject, "DISABLED") == 0) { LOC_LOGD("%s:%d]: Setting FREE_WIFI_SCAN_INJECT to mode: DISABLED", __func__, __LINE__); } - else if(strcmp(conf.feature_free_wifi_scan_inject, "PREMIUM") == 0) { + else if (strcmp(conf.feature_free_wifi_scan_inject, "PREMIUM") == 0) { LOC_LOGD("%s:%d]: Unrecognized value for FREE_WIFI_SCAN_INJECT mode."\ "Setting FREE_WIFI_SCAN_INJECT to default mode: BASIC", __func__, __LINE__); loc_service_mask |= LOC_FEATURE_MASK_FREE_WIFI_SCAN_INJECT; } // Set service mask for SUPL_WIFI - if(strcmp(conf.feature_supl_wifi, "BASIC") == 0) { + if (strcmp(conf.feature_supl_wifi, "BASIC") == 0) { LOC_LOGD("%s:%d]: Setting SUPL_WIFI to mode: BASIC", __func__, __LINE__); loc_service_mask |= LOC_FEATURE_MASK_SUPL_WIFI; } - else if(strcmp(conf.feature_supl_wifi, "DISABLED") == 0) { + else if (strcmp(conf.feature_supl_wifi, "DISABLED") == 0) { LOC_LOGD("%s:%d]: Setting SUPL_WIFI to mode: DISABLED", __func__, __LINE__); } - else if(strcmp(conf.feature_supl_wifi, "PREMIUM") == 0) { + else if (strcmp(conf.feature_supl_wifi, "PREMIUM") == 0) { LOC_LOGD("%s:%d]: Unrecognized value for SUPL_WIFI mode."\ "Setting SUPL_WIFI to default mode: BASIC", __func__, __LINE__); loc_service_mask |= LOC_FEATURE_MASK_SUPL_WIFI; } // Set service mask for WIFI_SUPPLICANT_INFO - if(strcmp(conf.feature_wifi_supplicant_info, "BASIC") == 0) { + if (strcmp(conf.feature_wifi_supplicant_info, "BASIC") == 0) { LOC_LOGD("%s:%d]: Setting WIFI_SUPPLICANT_INFO to mode: BASIC", __func__, __LINE__); loc_service_mask |= LOC_FEATURE_MASK_WIFI_SUPPLICANT_INFO; } - else if(strcmp(conf.feature_wifi_supplicant_info, "DISABLED") == 0) { + else if (strcmp(conf.feature_wifi_supplicant_info, "DISABLED") == 0) { LOC_LOGD("%s:%d]: Setting WIFI_SUPPLICANT_INFO to mode: DISABLED", __func__, __LINE__); } - else if(strcmp(conf.feature_wifi_supplicant_info, "PREMIUM") == 0) { + else if (strcmp(conf.feature_wifi_supplicant_info, "PREMIUM") == 0) { LOC_LOGD("%s:%d]: Unrecognized value for WIFI_SUPPLICANT_INFO mode."\ "Setting LOC_FEATURE_MASK_WIFI_SUPPLICANT_INFO to default mode: BASIC", __func__, __LINE__); loc_service_mask |= LOC_FEATURE_MASK_WIFI_SUPPLICANT_INFO; @@ -801,13 +805,13 @@ int loc_read_process_conf(const char* conf_file_name, uint32_t * process_count_p continue; } - if(strcmp(conf.proc_status, "DISABLED") == 0) { + if (strcmp(conf.proc_status, "DISABLED") == 0) { LOC_LOGD("%s:%d]: Process %s is disabled in conf file", __func__, __LINE__, conf.proc_name); child_proc[j].proc_status = DISABLED_FROM_CONF; continue; } - else if(strcmp(conf.proc_status, "ENABLED") == 0) { + else if (strcmp(conf.proc_status, "ENABLED") == 0) { LOC_LOGD("%s:%d]: Process %s is enabled in conf file", __func__, __LINE__, conf.proc_name); } @@ -832,7 +836,7 @@ int loc_read_process_conf(const char* conf_file_name, uint32_t * process_count_p } nstrings = loc_util_split_string(conf.platform_list, split_strings, MAX_NUM_STRINGS, ' '); - if(strcmp("all", split_strings[0]) == 0) { + if (strcmp("all", split_strings[0]) == 0) { if (nstrings == 1 || (nstrings == 2 && (strcmp("exclude", split_strings[1]) == 0))) { LOC_LOGD("%s:%d]: Enabled for all targets\n", __func__, __LINE__); config_mask |= CONFIG_MASK_TARGET_ALL; @@ -840,7 +844,7 @@ int loc_read_process_conf(const char* conf_file_name, uint32_t * process_count_p else if (nstrings > 2 && (strcmp("exclude", split_strings[1]) == 0)) { config_mask |= CONFIG_MASK_TARGET_FOUND; for (i=2; i 2 && (strcmp("exclude", split_strings[1]) == 0)) { config_mask |= CONFIG_MASK_BASEBAND_FOUND; for (i=2; i 0) { + uint64_t less1 = mask - 1; + bit = mask & ~(less1); + if (clearTheBit) { + mask &= less1; + } + } + + return bit; } -/* Get names from value */ -const char* loc_get_name_from_val(const loc_name_val_s_type table[], size_t table_size, long value) -{ - size_t i; - for (i = 0; i < table_size; i++) - { - if (table[i].val == (long) value) - { - return table[i].name; - } - } - return UNKNOWN_STR; +string loc_get_bit_defs(uint64_t mask, const NameValTbl& tbl) { + string out; + while (mask > 0) { + out += loc_get_name_from_tbl(tbl, loc_get_least_bit(mask)); + if (mask > 0) { + out += " | "; + } + } + return out; } -static const loc_name_val_s_type loc_msg_q_status[] = +DECLARE_TBL(loc_msg_q_status) = { NAME_VAL( eMSG_Q_SUCCESS ), NAME_VAL( eMSG_Q_FAILURE_GENERAL ), @@ -92,21 +97,15 @@ static const loc_name_val_s_type loc_msg_q_status[] = NAME_VAL( eMSG_Q_UNAVAILABLE_RESOURCE ), NAME_VAL( eMSG_Q_INSUFFICIENT_BUFFER ) }; -static const size_t loc_msg_q_status_num = LOC_TABLE_SIZE(loc_msg_q_status); /* Find msg_q status name */ const char* loc_get_msg_q_status(int status) { - return loc_get_name_from_val(loc_msg_q_status, loc_msg_q_status_num, (long) status); -} - -const char* log_succ_fail_string(int is_succ) -{ - return is_succ? "successful" : "failed"; + return loc_get_name_from_val(loc_msg_q_status_tbl, (int64_t) status); } //Target names -static const loc_name_val_s_type target_name[] = +DECLARE_TBL(target_name) = { NAME_VAL(GNSS_NONE), NAME_VAL(GNSS_MSM), @@ -116,8 +115,6 @@ static const loc_name_val_s_type target_name[] = NAME_VAL(GNSS_UNKNOWN) }; -static const size_t target_name_num = LOC_TABLE_SIZE(target_name); - /*=========================================================================== FUNCTION loc_get_target_name @@ -133,21 +130,13 @@ RETURN VALUE ===========================================================================*/ const char *loc_get_target_name(unsigned int target) { - int index = 0; + int64_t index = 0; static char ret[BUFFER_SIZE]; - index = getTargetGnssType(target); - if( index < 0 || (unsigned)index >= target_name_num ) - index = target_name_num - 1; + snprintf(ret, sizeof(ret), " %s with%s SSC", + loc_get_name_from_val(target_name_tbl, getTargetGnssType(target)), + ((target & HAS_SSC) == HAS_SSC) ? gEmptyStr.c_str() : "out"); - if( (target & HAS_SSC) == HAS_SSC ) { - snprintf(ret, sizeof(ret), " %s with SSC", - loc_get_name_from_val(target_name, target_name_num, (long)index) ); - } - else { - snprintf(ret, sizeof(ret), " %s without SSC", - loc_get_name_from_val(target_name, target_name_num, (long)index) ); - } return ret; } diff --git a/gps/utils/loc_log.h b/gps/utils/loc_log.h index be492b11..b750932d 100644 --- a/gps/utils/loc_log.h +++ b/gps/utils/loc_log.h @@ -1,4 +1,4 @@ -/* Copyright (c) 2011-2012, 2015 The Linux Foundation. All rights reserved. +/* Copyright (c) 2011-2012, 2015, 2020 The Linux Foundation. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are @@ -30,42 +30,93 @@ #ifndef LOC_LOG_H #define LOC_LOG_H -#ifdef __cplusplus -extern "C" -{ -#endif - #include #include +#include +#include #include "loc_target.h" +#include "loc_misc_utils.h" -typedef struct -{ - const char *name; - long val; -} loc_name_val_s_type; +using std::string; +using std::unordered_map; -#define NAME_VAL(x) {"" #x "", x } +typedef unordered_map NameValTbl; -#define UNKNOWN_STR "UNKNOWN" +#define NAME_VAL(x) {x, "" #x ""} +#define DECLARE_TBL(T) static const NameValTbl T##_tbl + +extern const string gEmptyStr; +extern const string gUnknownStr; #define CHECK_MASK(type, value, mask_var, mask) \ (((mask_var) & (mask)) ? (type) (value) : (type) (-1)) #define LOC_TABLE_SIZE(table) (sizeof(table)/sizeof((table)[0])) +#define FIELDVAL_DEC(field) \ + loc_put_tag_val(#field, to_string(field)) +#define FIELDVAL_DEC_ARR(field) \ + loc_put_tag_val(#field, \ + loc_parenthesize(loc_prim_arr_to_string(field, \ + sizeof(field)/sizeof(field[0])))) +#define FIELDVAL_HEX(field) \ + loc_put_tag_val(#field, to_string_hex(field)) +#define FIELDVAL_HEX_ARR(field) \ + loc_put_tag_val(#field, \ + loc_parenthesize(loc_prim_arr_to_string(field, \ + sizeof(field)/sizeof(field[0]), \ + false))) +#define FIELDVAL_ENUM(field, tbl) \ + loc_put_tag_val(#field, \ + loc_get_name_from_tbl(tbl, field, gUnknownStr)) +#define FIELDVAL_MASK(field, tbl) \ + loc_put_tag_val(#field, \ + to_string_hex((uint64_t)field) + " " + \ + loc_parenthesize(loc_get_bit_defs(field, tbl))) + +/* get from a table of strings with index */ +/* tbl - map of entries + key - key to the matching entry + defalt - default pointer in case of incorrect parameters + */ +inline static const string& loc_get_name_from_tbl(const NameValTbl& tbl, int64_t key, + const string& defalt = gEmptyStr) { + auto item = tbl.find(key); + if (item != tbl.end()) { + return item->second; + } else { + return defalt; + } +} + +/* puts to string formatted "TAG: VAL" with option ending string, default to newline */ +inline string loc_put_tag_val(const string& tag, const string& val, const string& eol = "\n") { + return tag + ": " + val + eol; +} + +inline string loc_parenthesize(const string& str) { + return "(" + str + ")"; +} + /* Get names from value */ -const char* loc_get_name_from_mask(const loc_name_val_s_type table[], size_t table_size, long mask); -const char* loc_get_name_from_val(const loc_name_val_s_type table[], size_t table_size, long value); +inline const char* loc_get_name_from_val(const NameValTbl& table, int64_t value) { + return loc_get_name_from_tbl(table, value, gUnknownStr).c_str(); +} + +inline const char* log_succ_fail_string(int is_succ) { + return is_succ? "successful" : "failed"; +} + +/* prints mask into a string with bit definitions from tbl */ +/* mask - bit mask, to be expanded into " BIT_NAMEx | BIT_NAMEy ... " + tbl - a table with defs for each bit, defined as entries + {{bit0, "BIT0_NAME"}, {bit1, "BIT1_NAME"}, .... {bitn, "BITn_NAME"} } + entries - number of strings in the table + */ +string loc_get_bit_defs(uint64_t mask, const NameValTbl& tbl); +uint64_t loc_get_least_bit(uint64_t& mask, bool clearThebit = true); const char* loc_get_msg_q_status(int status); const char* loc_get_target_name(unsigned int target); - -extern const char* log_succ_fail_string(int is_succ); - -extern char *loc_get_time(char *time_string, size_t buf_size); - -#ifdef __cplusplus -} -#endif +char *loc_get_time(char *time_string, size_t buf_size); #endif /* LOC_LOG_H */ diff --git a/gps/utils/loc_misc_utils.h b/gps/utils/loc_misc_utils.h index 046cb7cd..5e9b11ef 100644 --- a/gps/utils/loc_misc_utils.h +++ b/gps/utils/loc_misc_utils.h @@ -28,6 +28,9 @@ */ #ifndef _LOC_MISC_UTILS_H_ #define _LOC_MISC_UTILS_H_ +#include +#include +#include #ifdef __cplusplus extern "C" { @@ -137,13 +140,68 @@ RETURN VALUE SIDE EFFECTS N/A ===========================================================================*/ - - uint64_t getQTimerTickCount(); - #ifdef __cplusplus } #endif +using std::hex; +using std::string; +using std::stringstream; + +/*=========================================================================== +FUNCTION to_string_hex + +DESCRIPTION + This function works similar to std::to_string, but puts only in hex format. + +DEPENDENCIES + N/A + +RETURN VALUE + string, of input val in hex format + +SIDE EFFECTS + N/A +===========================================================================*/ +template +string to_string_hex(T val) { + stringstream ss; + if (val < 0) { + val = -val; + ss << "-"; + } + ss << hex << "0x" << val; + return ss.str(); +} + +/*=========================================================================== +FUNCTION loc_prim_arr_to_string + +DESCRIPTION + This function puts out primitive array in DEC or EHX format. + +DEPENDENCIES + N/A + +RETURN VALUE + string, space separated string of values in the input array, either + in decimal or hex format, depending on the value of decIfTrue + +SIDE EFFECTS + N/A +===========================================================================*/ +template +static string loc_prim_arr_to_string(T* arr, uint32_t size, bool decIfTrue = true) { + stringstream ss; + for (uint32_t i = 0; i < size; i++) { + ss << (decIfTrue ? to_string(arr[i]) : to_string_hex(arr[i])); + if (i != size - 1) { + ss << " "; + } + } + return ss.str(); +} + #endif //_LOC_MISC_UTILS_H_ diff --git a/gps/utils/loc_nmea.cpp b/gps/utils/loc_nmea.cpp index cc850a87..3f28f04c 100644 --- a/gps/utils/loc_nmea.cpp +++ b/gps/utils/loc_nmea.cpp @@ -130,12 +130,15 @@ typedef struct loc_sv_cache_info_s uint64_t bds_used_mask; uint64_t navic_used_mask; uint32_t gps_l1_count; + uint32_t gps_l2_count; uint32_t gps_l5_count; uint32_t glo_g1_count; uint32_t glo_g2_count; uint32_t gal_e1_count; uint32_t gal_e5_count; + uint32_t gal_e5b_count; uint32_t qzss_l1_count; + uint32_t qzss_l2_count; uint32_t qzss_l5_count; uint32_t bds_b1_count; uint32_t bds_b2_count; @@ -408,10 +411,16 @@ static loc_nmea_sv_meta* loc_nmea_sv_meta_init(loc_nmea_sv_meta& sv_meta, sv_meta.talker[1] = 'P'; sv_meta.mask = sv_cache_info.gps_used_mask; sv_meta.systemId = SYSTEM_ID_GPS; - if (GNSS_SIGNAL_GPS_L1CA == signalType) { - sv_meta.svCount = sv_cache_info.gps_l1_count; - } else if (GNSS_SIGNAL_GPS_L5 == signalType) { - sv_meta.svCount = sv_cache_info.gps_l5_count; + switch (signalType) { + case GNSS_SIGNAL_GPS_L1CA: + sv_meta.svCount = sv_cache_info.gps_l1_count; + break; + case GNSS_SIGNAL_GPS_L5: + sv_meta.svCount = sv_cache_info.gps_l5_count; + break; + case GNSS_SIGNAL_GPS_L2: + sv_meta.svCount = sv_cache_info.gps_l2_count; + break; } break; case GNSS_SV_TYPE_GLONASS: @@ -421,10 +430,13 @@ static loc_nmea_sv_meta* loc_nmea_sv_meta_init(loc_nmea_sv_meta& sv_meta, // GLONASS SV ids are from 65-96 sv_meta.svIdOffset = GLONASS_SV_ID_OFFSET; sv_meta.systemId = SYSTEM_ID_GLONASS; - if (GNSS_SIGNAL_GLONASS_G1 == signalType) { - sv_meta.svCount = sv_cache_info.glo_g1_count; - } else if (GNSS_SIGNAL_GLONASS_G2 == signalType) { - sv_meta.svCount = sv_cache_info.glo_g2_count; + switch (signalType) { + case GNSS_SIGNAL_GLONASS_G1: + sv_meta.svCount = sv_cache_info.glo_g1_count; + break; + case GNSS_SIGNAL_GLONASS_G2: + sv_meta.svCount = sv_cache_info.glo_g2_count; + break; } break; case GNSS_SV_TYPE_GALILEO: @@ -434,10 +446,16 @@ static loc_nmea_sv_meta* loc_nmea_sv_meta_init(loc_nmea_sv_meta& sv_meta, // GALILEO SV ids are from 301-336, So keep svIdOffset 300 sv_meta.svIdOffset = GALILEO_SV_ID_OFFSET; sv_meta.systemId = SYSTEM_ID_GALILEO; - if (GNSS_SIGNAL_GALILEO_E1 == signalType) { - sv_meta.svCount = sv_cache_info.gal_e1_count; - } else if (GNSS_SIGNAL_GALILEO_E5A == signalType) { - sv_meta.svCount = sv_cache_info.gal_e5_count; + switch (signalType) { + case GNSS_SIGNAL_GALILEO_E1: + sv_meta.svCount = sv_cache_info.gal_e1_count; + break; + case GNSS_SIGNAL_GALILEO_E5A: + sv_meta.svCount = sv_cache_info.gal_e5_count; + break; + case GNSS_SIGNAL_GALILEO_E5B: + sv_meta.svCount = sv_cache_info.gal_e5b_count; + break; } break; case GNSS_SV_TYPE_QZSS: @@ -447,10 +465,16 @@ static loc_nmea_sv_meta* loc_nmea_sv_meta_init(loc_nmea_sv_meta& sv_meta, // QZSS SV ids are from 193-197. So keep svIdOffset 192 sv_meta.svIdOffset = QZSS_SV_ID_OFFSET; sv_meta.systemId = SYSTEM_ID_QZSS; - if (GNSS_SIGNAL_QZSS_L1CA == signalType) { - sv_meta.svCount = sv_cache_info.qzss_l1_count; - } else if (GNSS_SIGNAL_QZSS_L5 == signalType) { - sv_meta.svCount = sv_cache_info.qzss_l5_count; + switch (signalType) { + case GNSS_SIGNAL_QZSS_L1CA: + sv_meta.svCount = sv_cache_info.qzss_l1_count; + break; + case GNSS_SIGNAL_QZSS_L2: + sv_meta.svCount = sv_cache_info.qzss_l2_count; + break; + case GNSS_SIGNAL_QZSS_L5: + sv_meta.svCount = sv_cache_info.qzss_l5_count; + break; } break; case GNSS_SV_TYPE_BEIDOU: @@ -460,10 +484,13 @@ static loc_nmea_sv_meta* loc_nmea_sv_meta_init(loc_nmea_sv_meta& sv_meta, // BDS SV ids are from 201-237. So keep svIdOffset 200 sv_meta.svIdOffset = BDS_SV_ID_OFFSET; sv_meta.systemId = SYSTEM_ID_BDS; - if (GNSS_SIGNAL_BEIDOU_B1I == signalType) { - sv_meta.svCount = sv_cache_info.bds_b1_count; - } else if (GNSS_SIGNAL_BEIDOU_B2AI == signalType) { - sv_meta.svCount = sv_cache_info.bds_b2_count; + switch (signalType) { + case GNSS_SIGNAL_BEIDOU_B1I: + sv_meta.svCount = sv_cache_info.bds_b1_count; + break; + case GNSS_SIGNAL_BEIDOU_B2AI: + sv_meta.svCount = sv_cache_info.bds_b2_count; + break; } break; case GNSS_SV_TYPE_NAVIC: @@ -472,8 +499,10 @@ static loc_nmea_sv_meta* loc_nmea_sv_meta_init(loc_nmea_sv_meta& sv_meta, sv_meta.mask = sv_cache_info.navic_used_mask; // NAVIC SV ids are from 401-414. So keep svIdOffset 0 sv_meta.systemId = SYSTEM_ID_NAVIC; - if (GNSS_SIGNAL_NAVIC_L5 == signalType) { - sv_meta.svCount = sv_cache_info.navic_l5_count; + switch (signalType) { + case GNSS_SIGNAL_NAVIC_L5: + sv_meta.svCount = sv_cache_info.navic_l5_count; + break; } break; default: @@ -2074,41 +2103,41 @@ void loc_nmea_generate_sv(const GnssSvNotification &svNotify, ENTRY_LOG(); char sentence[NMEA_SENTENCE_MAX_LENGTH] = {0}; - int svCount = svNotify.count; - int svNumber = 1; loc_sv_cache_info sv_cache_info = {}; //Count GPS SVs for saparating GPS from GLONASS and throw others - for(svNumber=1; svNumber <= svCount; svNumber++) { - if (GNSS_SV_TYPE_GPS == svNotify.gnssSvs[svNumber - 1].type) + for(uint32_t svOffset = 0; svOffset < svNotify.count; svOffset++) { + if (GNSS_SV_TYPE_GPS == svNotify.gnssSvs[svOffset].type) { // cache the used in fix mask, as it will be needed to send $GPGSA // during the position report if (GNSS_SV_OPTIONS_USED_IN_FIX_BIT == - (svNotify.gnssSvs[svNumber - 1].gnssSvOptionsMask & + (svNotify.gnssSvs[svOffset].gnssSvOptionsMask & GNSS_SV_OPTIONS_USED_IN_FIX_BIT)) { - sv_cache_info.gps_used_mask |= (1ULL << (svNotify.gnssSvs[svNumber - 1].svId - 1)); + setSvMask(sv_cache_info.gps_used_mask, svNotify.gnssSvs[svOffset].svId); } - if (GNSS_SIGNAL_GPS_L5 == svNotify.gnssSvs[svNumber - 1].gnssSignalTypeMask) { + if (GNSS_SIGNAL_GPS_L5 == svNotify.gnssSvs[svOffset].gnssSignalTypeMask) { sv_cache_info.gps_l5_count++; + } else if (GNSS_SIGNAL_GPS_L2 == svNotify.gnssSvs[svOffset].gnssSignalTypeMask) { + sv_cache_info.gps_l2_count++; } else { // GNSS_SIGNAL_GPS_L1CA or default // If no signal type in report, it means default L1 sv_cache_info.gps_l1_count++; } } - else if (GNSS_SV_TYPE_GLONASS == svNotify.gnssSvs[svNumber - 1].type) + else if (GNSS_SV_TYPE_GLONASS == svNotify.gnssSvs[svOffset].type) { // cache the used in fix mask, as it will be needed to send $GNGSA // during the position report if (GNSS_SV_OPTIONS_USED_IN_FIX_BIT == - (svNotify.gnssSvs[svNumber - 1].gnssSvOptionsMask & + (svNotify.gnssSvs[svOffset].gnssSvOptionsMask & GNSS_SV_OPTIONS_USED_IN_FIX_BIT)) { - sv_cache_info.glo_used_mask |= (1ULL << (svNotify.gnssSvs[svNumber - 1].svId - 1)); + setSvMask(sv_cache_info.glo_used_mask, svNotify.gnssSvs[svOffset].svId); } - if (GNSS_SIGNAL_GLONASS_G2 == svNotify.gnssSvs[svNumber - 1].gnssSignalTypeMask){ + if (GNSS_SIGNAL_GLONASS_G2 == svNotify.gnssSvs[svOffset].gnssSignalTypeMask){ sv_cache_info.glo_g2_count++; } else { // GNSS_SIGNAL_GLONASS_G1 or default @@ -2116,56 +2145,60 @@ void loc_nmea_generate_sv(const GnssSvNotification &svNotify, sv_cache_info.glo_g1_count++; } } - else if (GNSS_SV_TYPE_GALILEO == svNotify.gnssSvs[svNumber - 1].type) + else if (GNSS_SV_TYPE_GALILEO == svNotify.gnssSvs[svOffset].type) { // cache the used in fix mask, as it will be needed to send $GAGSA // during the position report if (GNSS_SV_OPTIONS_USED_IN_FIX_BIT == - (svNotify.gnssSvs[svNumber - 1].gnssSvOptionsMask & + (svNotify.gnssSvs[svOffset].gnssSvOptionsMask & GNSS_SV_OPTIONS_USED_IN_FIX_BIT)) { - sv_cache_info.gal_used_mask |= (1ULL << (svNotify.gnssSvs[svNumber - 1].svId - 1)); + setSvMask(sv_cache_info.gal_used_mask, svNotify.gnssSvs[svOffset].svId); } - if(GNSS_SIGNAL_GALILEO_E5A == svNotify.gnssSvs[svNumber - 1].gnssSignalTypeMask){ + if(GNSS_SIGNAL_GALILEO_E5A == svNotify.gnssSvs[svOffset].gnssSignalTypeMask){ sv_cache_info.gal_e5_count++; + } else if (GNSS_SIGNAL_GALILEO_E5B == svNotify.gnssSvs[svOffset].gnssSignalTypeMask) { + sv_cache_info.gal_e5b_count++; } else { // GNSS_SIGNAL_GALILEO_E1 or default // If no signal type in report, it means default E1 sv_cache_info.gal_e1_count++; } } - else if (GNSS_SV_TYPE_QZSS == svNotify.gnssSvs[svNumber - 1].type) + else if (GNSS_SV_TYPE_QZSS == svNotify.gnssSvs[svOffset].type) { // cache the used in fix mask, as it will be needed to send $PQGSA // during the position report if (GNSS_SV_OPTIONS_USED_IN_FIX_BIT == - (svNotify.gnssSvs[svNumber - 1].gnssSvOptionsMask & + (svNotify.gnssSvs[svOffset].gnssSvOptionsMask & GNSS_SV_OPTIONS_USED_IN_FIX_BIT)) { // For QZSS we adjusted SV id's in GnssAdapter, we need to re-adjust here - sv_cache_info.qzss_used_mask |= - (1ULL << (svNotify.gnssSvs[svNumber - 1].svId - (QZSS_SV_PRN_MIN - 1) - 1)); + setSvMask(sv_cache_info.qzss_used_mask, + svNotify.gnssSvs[svOffset].svId - (QZSS_SV_PRN_MIN - 1)); } - if (GNSS_SIGNAL_QZSS_L5 == svNotify.gnssSvs[svNumber - 1].gnssSignalTypeMask) { + if (GNSS_SIGNAL_QZSS_L5 == svNotify.gnssSvs[svOffset].gnssSignalTypeMask) { sv_cache_info.qzss_l5_count++; + } else if (GNSS_SIGNAL_QZSS_L2 == svNotify.gnssSvs[svOffset].gnssSignalTypeMask) { + sv_cache_info.qzss_l2_count++; } else { // GNSS_SIGNAL_QZSS_L1CA or default // If no signal type in report, it means default L1 sv_cache_info.qzss_l1_count++; } } - else if (GNSS_SV_TYPE_BEIDOU == svNotify.gnssSvs[svNumber - 1].type) + else if (GNSS_SV_TYPE_BEIDOU == svNotify.gnssSvs[svOffset].type) { // cache the used in fix mask, as it will be needed to send $PQGSA // during the position report if (GNSS_SV_OPTIONS_USED_IN_FIX_BIT == - (svNotify.gnssSvs[svNumber - 1].gnssSvOptionsMask & + (svNotify.gnssSvs[svOffset].gnssSvOptionsMask & GNSS_SV_OPTIONS_USED_IN_FIX_BIT)) { - sv_cache_info.bds_used_mask |= (1ULL << (svNotify.gnssSvs[svNumber - 1].svId - 1)); + setSvMask(sv_cache_info.bds_used_mask, svNotify.gnssSvs[svOffset].svId); } - if ((GNSS_SIGNAL_BEIDOU_B2AI == svNotify.gnssSvs[svNumber - 1].gnssSignalTypeMask) || - (GNSS_SIGNAL_BEIDOU_B2AQ == svNotify.gnssSvs[svNumber - 1].gnssSignalTypeMask)) { + if ((GNSS_SIGNAL_BEIDOU_B2AI == svNotify.gnssSvs[svOffset].gnssSignalTypeMask) || + (GNSS_SIGNAL_BEIDOU_B2AQ == svNotify.gnssSvs[svOffset].gnssSignalTypeMask)) { sv_cache_info.bds_b2_count++; } else { // GNSS_SIGNAL_BEIDOU_B1I or default @@ -2173,16 +2206,15 @@ void loc_nmea_generate_sv(const GnssSvNotification &svNotify, sv_cache_info.bds_b1_count++; } } - else if (GNSS_SV_TYPE_NAVIC == svNotify.gnssSvs[svNumber - 1].type) + else if (GNSS_SV_TYPE_NAVIC == svNotify.gnssSvs[svOffset].type) { // cache the used in fix mask, as it will be needed to send $PQGSA // during the position report if (GNSS_SV_OPTIONS_USED_IN_FIX_BIT == - (svNotify.gnssSvs[svNumber - 1].gnssSvOptionsMask & + (svNotify.gnssSvs[svOffset].gnssSvOptionsMask & GNSS_SV_OPTIONS_USED_IN_FIX_BIT)) { - sv_cache_info.navic_used_mask |= - (1ULL << (svNotify.gnssSvs[svNumber - 1].svId - 1)); + setSvMask(sv_cache_info.navic_used_mask, svNotify.gnssSvs[svOffset].svId); } // GNSS_SIGNAL_NAVIC_L5 is the only signal type for NAVIC sv_cache_info.navic_l5_count++; @@ -2205,6 +2237,14 @@ void loc_nmea_generate_sv(const GnssSvNotification &svNotify, loc_nmea_generate_GSV(svNotify, sentence, sizeof(sentence), loc_nmea_sv_meta_init(sv_meta, sv_cache_info, GNSS_SV_TYPE_GPS, GNSS_SIGNAL_GPS_L5, false), nmeaArraystr); + + // --------------------- + // ------$GPGSV:L2------ + // --------------------- + loc_nmea_generate_GSV(svNotify, sentence, sizeof(sentence), + loc_nmea_sv_meta_init(sv_meta, sv_cache_info, GNSS_SV_TYPE_GPS, + GNSS_SIGNAL_GPS_L2, false), nmeaArraystr); + // --------------------- // ------$GLGSV:G1------ // --------------------- @@ -2236,8 +2276,15 @@ void loc_nmea_generate_sv(const GnssSvNotification &svNotify, loc_nmea_sv_meta_init(sv_meta, sv_cache_info, GNSS_SV_TYPE_GALILEO, GNSS_SIGNAL_GALILEO_E5A, false), nmeaArraystr); + // ------------------------- + // ------$GAGSV:E5B--------- + // ------------------------- + loc_nmea_generate_GSV(svNotify, sentence, sizeof(sentence), + loc_nmea_sv_meta_init(sv_meta, sv_cache_info, GNSS_SV_TYPE_GALILEO, + GNSS_SIGNAL_GALILEO_E5B, false), nmeaArraystr); + // ----------------------------- - // ------$PQGSV (QZSS):L1CA----- + // ------$GQGSV (QZSS):L1CA----- // ----------------------------- loc_nmea_generate_GSV(svNotify, sentence, sizeof(sentence), @@ -2245,14 +2292,23 @@ void loc_nmea_generate_sv(const GnssSvNotification &svNotify, GNSS_SIGNAL_QZSS_L1CA, false), nmeaArraystr); // ----------------------------- - // ------$PQGSV (QZSS):L5------- + // ------$GQGSV (QZSS):L5------- // ----------------------------- loc_nmea_generate_GSV(svNotify, sentence, sizeof(sentence), loc_nmea_sv_meta_init(sv_meta, sv_cache_info, GNSS_SV_TYPE_QZSS, GNSS_SIGNAL_QZSS_L5, false), nmeaArraystr); + // ----------------------------- - // ------$PQGSV (BEIDOU:B1I)---- + // ------$GQGSV (QZSS):L2------- + // ----------------------------- + + loc_nmea_generate_GSV(svNotify, sentence, sizeof(sentence), + loc_nmea_sv_meta_init(sv_meta, sv_cache_info, GNSS_SV_TYPE_QZSS, + GNSS_SIGNAL_QZSS_L2, false), nmeaArraystr); + + // ----------------------------- + // ------$GBGSV (BEIDOU:B1I)---- // ----------------------------- loc_nmea_generate_GSV(svNotify, sentence, sizeof(sentence), @@ -2260,7 +2316,7 @@ void loc_nmea_generate_sv(const GnssSvNotification &svNotify, GNSS_SIGNAL_BEIDOU_B1I,false), nmeaArraystr); // ----------------------------- - // ------$PQGSV (BEIDOU:B2AI)--- + // ------$GBGSV (BEIDOU:B2AI)--- // ----------------------------- loc_nmea_generate_GSV(svNotify, sentence, sizeof(sentence),