From e7c30fa882af46d23f9eddf78fd66cd1bf89a65c Mon Sep 17 00:00:00 2001 From: Dante Russo Date: Wed, 1 May 2019 12:40:40 -0700 Subject: GNSS HIDL 2.0 updates Implement new GNSS HIDL 2.0 functions and callbacks gnssRequestLocationCb_2_0, getExtensionGnssBatching_2_0, getExtensionGnssDebug_2_0, getDebugData_2_0, injectBestLocation_2_0, gnssSetCapabilitiesCb_2_0, gnssLocationCb_2_0, gnssSvStatusCb_2_0, and gnssMeasurementCb_2_0. Fix VTS test failures from deprecated functions setGpsLock, setSuplEs, V1:0::getExtensionAGnss, and V1.0::getExtensionGnssNi CRs-fixed: 2433957 Change-Id: Id10cb41c32d6c50144b0501eb2d2eaf9c9a9aaec --- android/2.0/Gnss.cpp | 158 ++++++--- android/2.0/Gnss.h | 6 +- android/2.0/GnssBatching.cpp | 35 +- android/2.0/GnssBatching.h | 14 +- android/2.0/GnssConfiguration.cpp | 25 +- android/2.0/GnssDebug.cpp | 124 +++++++- android/2.0/GnssDebug.h | 11 +- android/2.0/location_api/BatchingAPIClient.cpp | 96 ++++-- android/2.0/location_api/BatchingAPIClient.h | 11 +- android/2.0/location_api/GnssAPIClient.cpp | 353 ++++++++++++++------- android/2.0/location_api/GnssAPIClient.h | 7 +- android/2.0/location_api/LocationUtil.cpp | 95 +++++- android/2.0/location_api/LocationUtil.h | 5 +- android/2.0/location_api/MeasurementAPIClient.cpp | 60 +++- .../1.0/MeasurementCorrections.cpp | 5 +- 15 files changed, 781 insertions(+), 224 deletions(-) (limited to 'android') diff --git a/android/2.0/Gnss.cpp b/android/2.0/Gnss.cpp index 1021938..0390af7 100644 --- a/android/2.0/Gnss.cpp +++ b/android/2.0/Gnss.cpp @@ -81,7 +81,6 @@ void Gnss::GnssDeathRecipient::serviceDied(uint64_t cookie, const wp& who LOC_LOGE("%s] service died. cookie: %llu, who: %p", __FUNCTION__, static_cast(cookie), &who); if (mGnss != nullptr) { - mGnss->stop(); mGnss->cleanup(); } } @@ -102,26 +101,31 @@ Gnss::~Gnss() { } GnssAPIClient* Gnss::getApi() { - if (mApi == nullptr && (mGnssCbIface != nullptr || mGnssNiCbIface != nullptr)) { + if (mApi != nullptr) { + return mApi; + } + + if (mGnssCbIface_2_0 != nullptr) { + mApi = new GnssAPIClient(mGnssCbIface_2_0); + } else if (mGnssCbIface_1_1 != nullptr) { + mApi = new GnssAPIClient(mGnssCbIface_1_1, mGnssNiCbIface); + } else if (mGnssCbIface != nullptr) { mApi = new GnssAPIClient(mGnssCbIface, mGnssNiCbIface); - if (mApi == nullptr) { - LOC_LOGE("%s] faild to create GnssAPIClient", __FUNCTION__); - return mApi; - } + } else { + LOC_LOGW("%s] GnssAPIClient is not ready", __FUNCTION__); + return mApi; + } - if (mPendingConfig.size == sizeof(GnssConfig)) { - // we have pending GnssConfig - mApi->gnssConfigurationUpdate(mPendingConfig); - // clear size to invalid mPendingConfig - mPendingConfig.size = 0; - if (mPendingConfig.assistanceServer.hostName != nullptr) { - free((void*)mPendingConfig.assistanceServer.hostName); - } + if (mPendingConfig.size == sizeof(GnssConfig)) { + // we have pending GnssConfig + mApi->gnssConfigurationUpdate(mPendingConfig); + // clear size to invalid mPendingConfig + mPendingConfig.size = 0; + if (mPendingConfig.assistanceServer.hostName != nullptr) { + free((void*)mPendingConfig.assistanceServer.hostName); } } - if (mApi == nullptr) { - LOC_LOGW("%s] GnssAPIClient is not ready", __FUNCTION__); - } + return mApi; } @@ -273,7 +277,23 @@ Return Gnss::cleanup() { ENTRY_LOG_CALLFLOW(); if (mApi != nullptr) { + mApi->gnssStop(); mApi->gnssDisable(); + mApi->gnssUpdateCallbacks(nullptr, nullptr); + mApi->gnssUpdateCallbacks_2_0(nullptr); + } + mGnssNiCbIface = nullptr; + if (mGnssCbIface != nullptr) { + mGnssCbIface->unlinkToDeath(mGnssDeathRecipient); + mGnssCbIface = nullptr; + } + if (mGnssCbIface_1_1 != nullptr) { + mGnssCbIface_1_1->unlinkToDeath(mGnssDeathRecipient); + mGnssCbIface_1_1 = nullptr; + } + if (mGnssCbIface_2_0 != nullptr) { + mGnssCbIface_2_0->unlinkToDeath(mGnssDeathRecipient); + mGnssCbIface_2_0 = nullptr; } return Void(); @@ -330,15 +350,14 @@ Return Gnss::setPositionMode(V1_0::IGnss::GnssPositionMode mode, Return> Gnss::getExtensionAGnss() { ENTRY_LOG_CALLFLOW(); - //mAGnssIface = new ::android::hardware::gnss::V1_1::implementation::AGnss(this); //need V1_1 AGnss - //return mAGnssIface; + // deprecated function. Must return nullptr to pass VTS return nullptr; } Return> Gnss::getExtensionGnssNi() { ENTRY_LOG_CALLFLOW(); - mGnssNi = new GnssNi(this); - return mGnssNi; + // deprecated function. Must return nullptr to pass VTS + return nullptr; } Return> Gnss::getExtensionGnssMeasurement() { @@ -381,8 +400,19 @@ Return> Gnss::getExtensionAGnssRil() { // Methods from ::android::hardware::gnss::V1_1::IGnss follow. Return Gnss::setCallback_1_1(const sp& callback) { ENTRY_LOG_CALLFLOW(); - callback->gnssNameCb(getVersionString()); + auto r = callback->gnssNameCb(getVersionString()); + if (!r.isOk()) { + LOC_LOGE("%s] Error from gnssNameCb description=%s", + __func__, r.description().c_str()); + } + if (mGnssCbIface_1_1 != nullptr) { + mGnssCbIface_1_1->unlinkToDeath(mGnssDeathRecipient); + } mGnssCbIface_1_1 = callback; + if (mGnssCbIface_1_1 != nullptr) { + mGnssCbIface_1_1->linkToDeath(mGnssDeathRecipient, 0 /*cookie*/); + } + const GnssInterface* gnssInterface = getGnssInterface(); if (nullptr != gnssInterface) { OdcpiRequestCallback cb = [this](const OdcpiRequestInfo& odcpiRequest) { @@ -390,7 +420,15 @@ Return Gnss::setCallback_1_1(const sp& callback) { }; gnssInterface->odcpiInit(cb); } - return setCallback(callback); + + GnssAPIClient* api = getApi(); + if (api != nullptr) { + api->gnssUpdateCallbacks(mGnssCbIface_1_1, mGnssNiCbIface); + api->gnssEnable(LOCATION_TECHNOLOGY_TYPE_GNSS); + api->requestCapabilities(); + } + + return true; } Return Gnss::setPositionMode_1_1(V1_0::IGnss::GnssPositionMode mode, @@ -442,7 +480,20 @@ Return Gnss::injectBestLocation(const GnssLocation& gnssLocation) { void Gnss::odcpiRequestCb(const OdcpiRequestInfo& request) { ENTRY_LOG_CALLFLOW(); - if (mGnssCbIface_1_1 != nullptr) { + + if (mGnssCbIface_2_0 != nullptr) { + // For emergency mode, request DBH (Device based hybrid) location + // Mark Independent from GNSS flag to false. + if (ODCPI_REQUEST_TYPE_START == request.type) { + auto r = mGnssCbIface_2_0->gnssRequestLocationCb_2_0(!request.isEmergencyMode, + request.isEmergencyMode); + if (!r.isOk()) { + LOC_LOGe("Error invoking gnssRequestLocationCb_2_0 %s", r.description().c_str()); + } + } else { + LOC_LOGv("Unsupported ODCPI request type: %d", request.type); + } + } else if (mGnssCbIface_1_1 != nullptr) { // For emergency mode, request DBH (Device based hybrid) location // Mark Independent from GNSS flag to false. if (ODCPI_REQUEST_TYPE_START == request.type) { @@ -461,8 +512,37 @@ void Gnss::odcpiRequestCb(const OdcpiRequestInfo& request) { // Methods from ::android::hardware::gnss::V2_0::IGnss follow. Return Gnss::setCallback_2_0(const sp& callback) { ENTRY_LOG_CALLFLOW(); - return setCallback_1_1(callback); + auto r = callback->gnssNameCb(getVersionString()); + if (!r.isOk()) { + LOC_LOGE("%s] Error from gnssNameCb description=%s", + __func__, r.description().c_str()); + } + if (mGnssCbIface_2_0 != nullptr) { + mGnssCbIface_2_0->unlinkToDeath(mGnssDeathRecipient); + } + mGnssCbIface_2_0 = callback; + if (mGnssCbIface_2_0 != nullptr) { + mGnssCbIface_2_0->linkToDeath(mGnssDeathRecipient, 0 /*cookie*/); + } + + const GnssInterface* gnssInterface = getGnssInterface(); + if (nullptr != gnssInterface) { + OdcpiRequestCallback cb = [this](const OdcpiRequestInfo& odcpiRequest) { + odcpiRequestCb(odcpiRequest); + }; + gnssInterface->odcpiInit(cb); + } + + GnssAPIClient* api = getApi(); + if (api != nullptr) { + api->gnssUpdateCallbacks_2_0(mGnssCbIface_2_0); + api->gnssEnable(LOCATION_TECHNOLOGY_TYPE_GNSS); + api->requestCapabilities(); + } + + return true; } + Return> Gnss::getExtensionAGnss_2_0() { ENTRY_LOG_CALLFLOW(); mAGnssIface_2_0 = new AGnss(this); @@ -490,10 +570,8 @@ Return> Gnss::getExtensionGnssMeasurement_2_0() { } Return> Gnss::getExtensionMeasurementCorrections() { - if (mGnssMeasCorr == nullptr) { - mGnssMeasCorr = new MeasurementCorrections(); - } - return mGnssMeasCorr; + // We do not support, so return nullptr to pass VTS + return nullptr; } Return> Gnss::getExtensionVisibilityControl() { @@ -504,21 +582,27 @@ Return Gnss::injectBestLocation_2_0( - const ::android::hardware::gnss::V2_0::GnssLocation& location) { +Return Gnss::injectBestLocation_2_0(const V2_0::GnssLocation& gnssLocation) { ENTRY_LOG_CALLFLOW(); - /* TBD */ - return false; + const GnssInterface* gnssInterface = getGnssInterface(); + if (nullptr != gnssInterface) { + Location location = {}; + convertGnssLocation(gnssLocation, location); + gnssInterface->odcpiInject(location); + } + return true; } -Return> Gnss::getExtensionGnssBatching_2_0() { +Return> Gnss::getExtensionGnssDebug_2_0() { ENTRY_LOG_CALLFLOW(); - return nullptr; + mGnssDebug = new GnssDebug(this); + return mGnssDebug; } -Return> Gnss::getExtensionGnssDebug_2_0() { +Return> Gnss::getExtensionGnssBatching_2_0() { ENTRY_LOG_CALLFLOW(); - return nullptr; + mGnssBatching = new GnssBatching(); + return mGnssBatching; } V1_0::IGnss* HIDL_FETCH_IGnss(const char* hal) { diff --git a/android/2.0/Gnss.h b/android/2.0/Gnss.h index df62901..a403d61 100644 --- a/android/2.0/Gnss.h +++ b/android/2.0/Gnss.h @@ -142,6 +142,7 @@ struct Gnss : public IGnss { // Callback for ODCPI request void odcpiRequestCb(const OdcpiRequestInfo& request); + private: struct GnssDeathRecipient : hidl_death_recipient { GnssDeathRecipient(sp gnss) : mGnss(gnss) { @@ -156,8 +157,6 @@ struct Gnss : public IGnss { sp mGnssNi = nullptr; sp mGnssGeofencingIface = nullptr; - sp mGnssBatching = nullptr; - sp mGnssDebug = nullptr; sp mAGnssIface = nullptr; sp mGnssCbIface = nullptr; sp mGnssNiCbIface = nullptr; @@ -166,6 +165,9 @@ struct Gnss : public IGnss { sp mGnssRil = nullptr; sp mGnssMeasurement = nullptr; sp mGnssConfig = nullptr; + sp mGnssBatching = nullptr; + sp mGnssDebug = nullptr; + sp mGnssCbIface_2_0 = nullptr; sp mGnssMeasCorr = nullptr; sp mVisibCtrl = nullptr; diff --git a/android/2.0/GnssBatching.cpp b/android/2.0/GnssBatching.cpp index cf215ea..7a937fc 100644 --- a/android/2.0/GnssBatching.cpp +++ b/android/2.0/GnssBatching.cpp @@ -53,7 +53,7 @@ GnssBatching::~GnssBatching() { // Methods from ::android::hardware::gnss::V1_0::IGnssBatching follow. -Return GnssBatching::init(const sp& callback) { +Return GnssBatching::init(const sp& callback) { if (mApi != nullptr) { LOC_LOGD("%s]: mApi is NOT nullptr, delete it first", __FUNCTION__); delete mApi; @@ -117,12 +117,45 @@ Return GnssBatching::stop() { } Return GnssBatching::cleanup() { + if (mApi != nullptr) { + mApi->stopSession(); + } if (mGnssBatchingCbIface != nullptr) { mGnssBatchingCbIface->unlinkToDeath(mGnssBatchingDeathRecipient); + mGnssBatchingCbIface = nullptr; + } + if (mGnssBatchingCbIface_2_0 != nullptr) { + mGnssBatchingCbIface_2_0->unlinkToDeath(mGnssBatchingDeathRecipient); + mGnssBatchingCbIface_2_0 = nullptr; } return Void(); } +// Methods from ::android::hardware::gnss::V2_0::IGnssBatching follow. +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 = nullptr; + } + + mApi = new BatchingAPIClient(callback); + if (mApi == nullptr) { + LOC_LOGE("%s]: failed to create mApi", __FUNCTION__); + return false; + } + + if (mGnssBatchingCbIface_2_0 != nullptr) { + mGnssBatchingCbIface_2_0->unlinkToDeath(mGnssBatchingDeathRecipient); + } + mGnssBatchingCbIface_2_0 = callback; + if (mGnssBatchingCbIface_2_0 != nullptr) { + mGnssBatchingCbIface_2_0->linkToDeath(mGnssBatchingDeathRecipient, 0 /*cookie*/); + } + + return true; +} + } // namespace implementation } // namespace V2_0 } // namespace gnss diff --git a/android/2.0/GnssBatching.h b/android/2.0/GnssBatching.h index f7dc65b..4c8d1db 100644 --- a/android/2.0/GnssBatching.h +++ b/android/2.0/GnssBatching.h @@ -21,7 +21,7 @@ #ifndef ANDROID_HARDWARE_GNSS_V2_0_GNSSBATCHING_H #define ANDROID_HARDWARE_GNSS_V2_0_GNSSBATCHING_H -#include +#include #include @@ -31,8 +31,8 @@ namespace gnss { namespace V2_0 { namespace implementation { -using ::android::hardware::gnss::V1_0::IGnssBatching; -using ::android::hardware::gnss::V1_0::IGnssBatchingCallback; +using ::android::hardware::gnss::V2_0::IGnssBatching; +using ::android::hardware::gnss::V2_0::IGnssBatchingCallback; using ::android::hidl::base::V1_0::IBase; using ::android::hardware::hidl_array; using ::android::hardware::hidl_memory; @@ -48,13 +48,16 @@ struct GnssBatching : public IGnssBatching { ~GnssBatching(); // Methods from ::android::hardware::gnss::V1_0::IGnssBatching follow. - Return init(const sp& callback) override; + Return init(const sp& callback) override; Return getBatchSize() override; Return start(const IGnssBatching::Options& options ) override; Return flush() override; Return stop() override; Return cleanup() override; + // Methods from ::android::hardware::gnss::V2_0::IGnssBatching follow. + Return init_2_0(const sp& callback) override; + private: struct GnssBatchingDeathRecipient : hidl_death_recipient { GnssBatchingDeathRecipient(sp gnssBatching) : @@ -67,8 +70,9 @@ struct GnssBatching : public IGnssBatching { private: sp mGnssBatchingDeathRecipient = nullptr; - sp mGnssBatchingCbIface = nullptr; + sp mGnssBatchingCbIface = nullptr; BatchingAPIClient* mApi = nullptr; + sp mGnssBatchingCbIface_2_0 = nullptr; }; } // namespace implementation diff --git a/android/2.0/GnssConfiguration.cpp b/android/2.0/GnssConfiguration.cpp index eb98be1..671b6e7 100644 --- a/android/2.0/GnssConfiguration.cpp +++ b/android/2.0/GnssConfiguration.cpp @@ -38,20 +38,8 @@ GnssConfiguration::GnssConfiguration(Gnss* gnss) : mGnss(gnss) { // Methods from ::android::hardware::gps::V1_0::IGnssConfiguration follow. Return GnssConfiguration::setSuplEs(bool enabled) { - if (mGnss == nullptr) { - LOC_LOGE("%s]: mGnss is nullptr", __FUNCTION__); - return false; - } - - GnssConfig config; - memset(&config, 0, sizeof(GnssConfig)); - config.size = sizeof(GnssConfig); - config.flags = GNSS_CONFIG_FLAGS_SUPL_EM_SERVICES_BIT; - config.suplEmergencyServices = (enabled ? - GNSS_CONFIG_SUPL_EMERGENCY_SERVICES_YES : - GNSS_CONFIG_SUPL_EMERGENCY_SERVICES_NO); - - return mGnss->updateConfiguration(config); + // deprecated function. Must return false to pass VTS + return false; } Return GnssConfiguration::setSuplVersion(uint32_t version) { @@ -174,10 +162,9 @@ Return GnssConfiguration::setGlonassPositioningProtocol(uint8_t protocol) return mGnss->updateConfiguration(config); } -Return GnssConfiguration::setGpsLock(uint8_t lock) { - /* we no longer set GPS lock here, there is - visibility control for this */ - return true; +Return GnssConfiguration::setGpsLock(uint8_t /*lock*/) { + // deprecated function. Must return false to pass VTS + return false; } Return GnssConfiguration::setEmergencySuplPdn(bool enabled) { @@ -268,7 +255,7 @@ bool GnssConfiguration::setBlacklistedSource( break; default: copyToSource.constellation = GNSS_SV_TYPE_UNKNOWN; - LOC_LOGe("Invalid constellation %d", copyFromSource.constellation); + LOC_LOGe("Invalid constellation %u", copyFromSource.constellation); retVal = false; break; } diff --git a/android/2.0/GnssDebug.cpp b/android/2.0/GnssDebug.cpp index 582acc9..b6b9bfe 100644 --- a/android/2.0/GnssDebug.cpp +++ b/android/2.0/GnssDebug.cpp @@ -33,6 +33,7 @@ namespace V2_0 { namespace implementation { using ::android::hardware::hidl_vec; +using ::android::hardware::gnss::V2_0::IGnssDebug; #define GNSS_DEBUG_UNKNOWN_HORIZONTAL_ACCURACY_METERS (20000000) #define GNSS_DEBUG_UNKNOWN_VERTICAL_ACCURACY_METERS (20000) @@ -57,7 +58,7 @@ Return GnssDebug::getDebugData(getDebugData_cb _hidl_cb) { LOC_LOGD("%s]: ", __func__); - DebugData data = { }; + V1_0::IGnssDebug::DebugData data = { }; if((nullptr == mGnss) || (nullptr == mGnss->getGnssInterface())){ LOC_LOGE("GnssDebug - Null GNSS interface"); @@ -139,8 +140,8 @@ Return GnssDebug::getDebugData(getDebugData_cb _hidl_cb) } // satellite data block - SatelliteData s = { }; - std::vector s_array = { }; + V1_0::IGnssDebug::SatelliteData s = { }; + std::vector s_array; for (uint32_t i=0; i GnssDebug::getDebugData(getDebugData_cb _hidl_cb) return Void(); } +Return GnssDebug::getDebugData_2_0(getDebugData_2_0_cb _hidl_cb) +{ + LOC_LOGD("%s]: ", __func__); + + V2_0::IGnssDebug::DebugData data = { }; + + if((nullptr == mGnss) || (nullptr == mGnss->getGnssInterface())){ + LOC_LOGE("GnssDebug - Null GNSS interface"); + _hidl_cb(data); + return Void(); + } + + // get debug report snapshot via hal interface + GnssDebugReport reports = { }; + mGnss->getGnssInterface()->getDebugReport(reports); + + // location block + if (reports.mLocation.mValid) { + data.position.valid = true; + data.position.latitudeDegrees = reports.mLocation.mLocation.latitude; + data.position.longitudeDegrees = reports.mLocation.mLocation.longitude; + data.position.altitudeMeters = reports.mLocation.mLocation.altitude; + + data.position.speedMetersPerSec = + (double)(reports.mLocation.mLocation.speed); + data.position.bearingDegrees = + (double)(reports.mLocation.mLocation.bearing); + data.position.horizontalAccuracyMeters = + (double)(reports.mLocation.mLocation.accuracy); + data.position.verticalAccuracyMeters = + reports.mLocation.verticalAccuracyMeters; + data.position.speedAccuracyMetersPerSecond = + reports.mLocation.speedAccuracyMetersPerSecond; + data.position.bearingAccuracyDegrees = + reports.mLocation.bearingAccuracyDegrees; + + timeval tv_now, tv_report; + tv_report.tv_sec = reports.mLocation.mUtcReported.tv_sec; + tv_report.tv_usec = reports.mLocation.mUtcReported.tv_nsec / 1000ULL; + gettimeofday(&tv_now, NULL); + data.position.ageSeconds = + (tv_now.tv_sec - tv_report.tv_sec) + + (float)((tv_now.tv_usec - tv_report.tv_usec)) / 1000000; + } + else { + data.position.valid = false; + } + + if (data.position.horizontalAccuracyMeters <= 0 || + data.position.horizontalAccuracyMeters > GNSS_DEBUG_UNKNOWN_HORIZONTAL_ACCURACY_METERS) { + data.position.horizontalAccuracyMeters = GNSS_DEBUG_UNKNOWN_HORIZONTAL_ACCURACY_METERS; + } + if (data.position.verticalAccuracyMeters <= 0 || + data.position.verticalAccuracyMeters > GNSS_DEBUG_UNKNOWN_VERTICAL_ACCURACY_METERS) { + data.position.verticalAccuracyMeters = GNSS_DEBUG_UNKNOWN_VERTICAL_ACCURACY_METERS; + } + if (data.position.speedAccuracyMetersPerSecond <= 0 || + data.position.speedAccuracyMetersPerSecond > GNSS_DEBUG_UNKNOWN_SPEED_ACCURACY_PER_SEC) { + data.position.speedAccuracyMetersPerSecond = GNSS_DEBUG_UNKNOWN_SPEED_ACCURACY_PER_SEC; + } + if (data.position.bearingAccuracyDegrees <= 0 || + data.position.bearingAccuracyDegrees > GNSS_DEBUG_UNKNOWN_BEARING_ACCURACY_DEG) { + data.position.bearingAccuracyDegrees = GNSS_DEBUG_UNKNOWN_BEARING_ACCURACY_DEG; + } + + // time block + if (reports.mTime.mValid) { + data.time.timeEstimate = reports.mTime.timeEstimate; + data.time.timeUncertaintyNs = reports.mTime.timeUncertaintyNs; + data.time.frequencyUncertaintyNsPerSec = + reports.mTime.frequencyUncertaintyNsPerSec; + } + + if (data.time.timeEstimate < GNSS_DEBUG_UNKNOWN_UTC_TIME) { + data.time.timeEstimate = GNSS_DEBUG_UNKNOWN_UTC_TIME; + } + if (data.time.timeUncertaintyNs <= 0 || + data.time.timeUncertaintyNs > (float)GNSS_DEBUG_UNKNOWN_UTC_TIME_UNC) { + data.time.timeUncertaintyNs = (float)GNSS_DEBUG_UNKNOWN_UTC_TIME_UNC; + } + if (data.time.frequencyUncertaintyNsPerSec <= 0 || + data.time.frequencyUncertaintyNsPerSec > (float)GNSS_DEBUG_UNKNOWN_FREQ_UNC_NS_PER_SEC) { + data.time.frequencyUncertaintyNsPerSec = (float)GNSS_DEBUG_UNKNOWN_FREQ_UNC_NS_PER_SEC; + } + + // satellite data block + V2_0::IGnssDebug::SatelliteData s = { }; + std::vector s_array; + + for (uint32_t i=0; i +#include #include namespace android { @@ -31,7 +31,7 @@ namespace gnss { namespace V2_0 { namespace implementation { -using ::android::hardware::gnss::V1_0::IGnssDebug; +using ::android::hardware::gnss::V2_0::IGnssDebug; using ::android::hardware::Return; using ::android::hardware::Void; using ::android::hardware::hidl_vec; @@ -44,11 +44,10 @@ struct GnssDebug : public IGnssDebug { GnssDebug(Gnss* gnss); ~GnssDebug() {}; - /* - * Methods from ::android::hardware::gnss::V1_0::IGnssDebug follow. - * These declarations were generated from IGnssDebug.hal. - */ + // Methods from ::android::hardware::gnss::V1_0::IGnssDebug follow Return getDebugData(getDebugData_cb _hidl_cb) override; + // Methods from ::android::hardware::gnss::V2_0::IGnssDebug follow. + Return getDebugData_2_0(getDebugData_2_0_cb _hidl_cb) override; private: Gnss* mGnss = nullptr; diff --git a/android/2.0/location_api/BatchingAPIClient.cpp b/android/2.0/location_api/BatchingAPIClient.cpp index 48caee6..49cd18a 100644 --- a/android/2.0/location_api/BatchingAPIClient.cpp +++ b/android/2.0/location_api/BatchingAPIClient.cpp @@ -45,33 +45,60 @@ namespace gnss { namespace V2_0 { namespace implementation { -using ::android::hardware::gnss::V1_0::IGnssBatching; -using ::android::hardware::gnss::V1_0::IGnssBatchingCallback; -using ::android::hardware::gnss::V1_0::GnssLocation; +using ::android::hardware::gnss::V2_0::IGnssBatching; +using ::android::hardware::gnss::V2_0::IGnssBatchingCallback; +using ::android::hardware::gnss::V2_0::GnssLocation; static void convertBatchOption(const IGnssBatching::Options& in, LocationOptions& out, LocationCapabilitiesMask mask); -BatchingAPIClient::BatchingAPIClient(const sp& callback) : +BatchingAPIClient::BatchingAPIClient(const sp& callback) : LocationAPIClientBase(), - mGnssBatchingCbIface(callback), + mGnssBatchingCbIface(nullptr), mDefaultId(UINT_MAX), - mLocationCapabilitiesMask(0) + mLocationCapabilitiesMask(0), + mGnssBatchingCbIface_2_0(nullptr) { LOC_LOGD("%s]: (%p)", __FUNCTION__, &callback); + gnssUpdateCallbacks(callback); +} + +BatchingAPIClient::BatchingAPIClient(const sp& callback) : + LocationAPIClientBase(), + mGnssBatchingCbIface(nullptr), + mDefaultId(UINT_MAX), + mLocationCapabilitiesMask(0), + mGnssBatchingCbIface_2_0(nullptr) +{ + LOC_LOGD("%s]: (%p)", __FUNCTION__, &callback); + + gnssUpdateCallbacks_2_0(callback); +} + +BatchingAPIClient::~BatchingAPIClient() +{ + LOC_LOGD("%s]: ()", __FUNCTION__); +} + +int BatchingAPIClient::getBatchSize() +{ + LOC_LOGD("%s]: ()", __FUNCTION__); + return locAPIGetBatchSize(); +} + +void BatchingAPIClient::setCallbacks() +{ LocationCallbacks locationCallbacks; memset(&locationCallbacks, 0, sizeof(LocationCallbacks)); locationCallbacks.size = sizeof(LocationCallbacks); locationCallbacks.trackingCb = nullptr; locationCallbacks.batchingCb = nullptr; - if (mGnssBatchingCbIface != nullptr) { - locationCallbacks.batchingCb = [this](size_t count, Location* location, - BatchingOptions batchOptions) { - onBatchingCb(count, location, batchOptions); - }; - } + locationCallbacks.batchingCb = [this](size_t count, Location* location, + BatchingOptions batchOptions) { + onBatchingCb(count, location, batchOptions); + }; locationCallbacks.geofenceBreachCb = nullptr; locationCallbacks.geofenceStatusCb = nullptr; locationCallbacks.gnssLocationInfoCb = nullptr; @@ -83,15 +110,26 @@ BatchingAPIClient::BatchingAPIClient(const sp& callback) locAPISetCallbacks(locationCallbacks); } -BatchingAPIClient::~BatchingAPIClient() +void BatchingAPIClient::gnssUpdateCallbacks(const sp& callback) { - LOC_LOGD("%s]: ()", __FUNCTION__); + mMutex.lock(); + mGnssBatchingCbIface = callback; + mMutex.unlock(); + + if (mGnssBatchingCbIface != nullptr) { + setCallbacks(); + } } -int BatchingAPIClient::getBatchSize() +void BatchingAPIClient::gnssUpdateCallbacks_2_0(const sp& callback) { - LOC_LOGD("%s]: ()", __FUNCTION__); - return locAPIGetBatchSize(); + mMutex.lock(); + mGnssBatchingCbIface_2_0 = callback; + mMutex.unlock(); + + if (mGnssBatchingCbIface_2_0 != nullptr) { + setCallbacks(); + } } int BatchingAPIClient::startSession(const IGnssBatching::Options& opts) @@ -160,16 +198,32 @@ void BatchingAPIClient::onCapabilitiesCb(LocationCapabilitiesMask capabilitiesMa void BatchingAPIClient::onBatchingCb(size_t count, Location* location, BatchingOptions /*batchOptions*/) { + mMutex.lock(); + auto gnssBatchingCbIface(mGnssBatchingCbIface); + auto gnssBatchingCbIface_2_0(mGnssBatchingCbIface_2_0); + mMutex.unlock(); + LOC_LOGD("%s]: (count: %zu)", __FUNCTION__, count); - if (mGnssBatchingCbIface != nullptr && count > 0) { - hidl_vec locationVec; + if (gnssBatchingCbIface_2_0 != nullptr && count > 0) { + hidl_vec locationVec; + locationVec.resize(count); + for (size_t i = 0; i < count; i++) { + convertGnssLocation(location[i], locationVec[i]); + } + auto r = gnssBatchingCbIface_2_0->gnssLocationBatchCb(locationVec); + if (!r.isOk()) { + LOC_LOGE("%s] Error from gnssLocationBatchCb 2.0 description=%s", + __func__, r.description().c_str()); + } + } else if (gnssBatchingCbIface != nullptr && count > 0) { + hidl_vec locationVec; locationVec.resize(count); for (size_t i = 0; i < count; i++) { convertGnssLocation(location[i], locationVec[i]); } - auto r = mGnssBatchingCbIface->gnssLocationBatchCb(locationVec); + auto r = gnssBatchingCbIface->gnssLocationBatchCb(locationVec); if (!r.isOk()) { - LOC_LOGE("%s] Error from gnssLocationBatchCb description=%s", + LOC_LOGE("%s] Error from gnssLocationBatchCb 1.0 description=%s", __func__, r.description().c_str()); } } diff --git a/android/2.0/location_api/BatchingAPIClient.h b/android/2.0/location_api/BatchingAPIClient.h index 33a8c2e..7198341 100644 --- a/android/2.0/location_api/BatchingAPIClient.h +++ b/android/2.0/location_api/BatchingAPIClient.h @@ -30,8 +30,9 @@ #ifndef BATCHING_API_CLINET_H #define BATCHING_API_CLINET_H -#include -#include +#include +#include +#include #include #include @@ -46,6 +47,9 @@ class BatchingAPIClient : public LocationAPIClientBase { public: BatchingAPIClient(const sp& callback); + 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); @@ -61,9 +65,12 @@ public: void onBatchingCb(size_t count, Location* location, BatchingOptions batchOptions) final; private: + void setCallbacks(); + std::mutex mMutex; sp mGnssBatchingCbIface; uint32_t mDefaultId; LocationCapabilitiesMask mLocationCapabilitiesMask; + sp mGnssBatchingCbIface_2_0; }; } // namespace implementation diff --git a/android/2.0/location_api/GnssAPIClient.cpp b/android/2.0/location_api/GnssAPIClient.cpp index 44ae284..5610f06 100644 --- a/android/2.0/location_api/GnssAPIClient.cpp +++ b/android/2.0/location_api/GnssAPIClient.cpp @@ -44,34 +44,46 @@ namespace gnss { namespace V2_0 { namespace implementation { -using ::android::hardware::gnss::V1_0::IGnss; -using ::android::hardware::gnss::V1_0::IGnssCallback; +using ::android::hardware::gnss::V2_0::IGnss; +using ::android::hardware::gnss::V2_0::IGnssCallback; using ::android::hardware::gnss::V1_0::IGnssNiCallback; -using ::android::hardware::gnss::V1_0::GnssLocation; +using ::android::hardware::gnss::V2_0::GnssLocation; -static void convertGnssSvStatus(GnssSvNotification& in, IGnssCallback::GnssSvStatus& out); +static void convertGnssSvStatus(GnssSvNotification& in, V1_0::IGnssCallback::GnssSvStatus& out); +static void convertGnssSvStatus(GnssSvNotification& in, + hidl_vec& out); -GnssAPIClient::GnssAPIClient(const sp& gpsCb, - const sp& niCb) : +GnssAPIClient::GnssAPIClient(const sp& gpsCb, + const sp& niCb) : LocationAPIClientBase(), mGnssCbIface(nullptr), mGnssNiCbIface(nullptr), mControlClient(new LocationAPIControlClient()), mLocationCapabilitiesMask(0), - mLocationCapabilitiesCached(false) + mLocationCapabilitiesCached(false), + mGnssCbIface_2_0(nullptr) { LOC_LOGD("%s]: (%p %p)", __FUNCTION__, &gpsCb, &niCb); - // set default LocationOptions. - memset(&mTrackingOptions, 0, sizeof(TrackingOptions)); - mTrackingOptions.size = sizeof(TrackingOptions); - mTrackingOptions.minInterval = 1000; - mTrackingOptions.minDistance = 0; - mTrackingOptions.mode = GNSS_SUPL_MODE_STANDALONE; - + initLocationOptions(); gnssUpdateCallbacks(gpsCb, niCb); } +GnssAPIClient::GnssAPIClient(const sp& gpsCb) : + LocationAPIClientBase(), + mGnssCbIface(nullptr), + mGnssNiCbIface(nullptr), + mControlClient(new LocationAPIControlClient()), + mLocationCapabilitiesMask(0), + mLocationCapabilitiesCached(false), + mGnssCbIface_2_0(nullptr) +{ + LOC_LOGD("%s]: (%p)", __FUNCTION__, &gpsCb); + + initLocationOptions(); + gnssUpdateCallbacks_2_0(gpsCb); +} + GnssAPIClient::~GnssAPIClient() { LOC_LOGD("%s]: ()", __FUNCTION__); @@ -81,64 +93,89 @@ GnssAPIClient::~GnssAPIClient() } } -// for GpsInterface -void GnssAPIClient::gnssUpdateCallbacks(const sp& gpsCb, - const sp& niCb) +void GnssAPIClient::initLocationOptions() { - LOC_LOGD("%s]: (%p %p)", __FUNCTION__, &gpsCb, &niCb); - - mMutex.lock(); - mGnssCbIface = gpsCb; - mGnssNiCbIface = niCb; - mMutex.unlock(); + // set default LocationOptions. + memset(&mTrackingOptions, 0, sizeof(TrackingOptions)); + mTrackingOptions.size = sizeof(TrackingOptions); + mTrackingOptions.minInterval = 1000; + mTrackingOptions.minDistance = 0; + mTrackingOptions.mode = GNSS_SUPL_MODE_STANDALONE; +} +void GnssAPIClient::setCallbacks() +{ LocationCallbacks locationCallbacks; memset(&locationCallbacks, 0, sizeof(LocationCallbacks)); locationCallbacks.size = sizeof(LocationCallbacks); locationCallbacks.trackingCb = nullptr; - if (mGnssCbIface != nullptr) { - locationCallbacks.trackingCb = [this](Location location) { - onTrackingCb(location); - }; - } + locationCallbacks.trackingCb = [this](Location location) { + onTrackingCb(location); + }; locationCallbacks.batchingCb = nullptr; locationCallbacks.geofenceBreachCb = nullptr; locationCallbacks.geofenceStatusCb = nullptr; locationCallbacks.gnssLocationInfoCb = nullptr; - locationCallbacks.gnssNiCb = nullptr; - loc_core::ContextBase* context = - loc_core::LocContext::getLocContext( - NULL, NULL, - loc_core::LocContext::mLocationHalName, false); - if (mGnssNiCbIface != nullptr && !context->hasAgpsExtendedCapabilities()) { - LOC_LOGD("Registering NI CB"); - locationCallbacks.gnssNiCb = [this](uint32_t id, GnssNiNotification gnssNiNotification) { - onGnssNiCb(id, gnssNiNotification); - }; + if (mGnssNiCbIface != nullptr) { + loc_core::ContextBase* context = + loc_core::LocContext::getLocContext( + NULL, NULL, + loc_core::LocContext::mLocationHalName, false); + if (!context->hasAgpsExtendedCapabilities()) { + LOC_LOGD("Registering NI CB"); + locationCallbacks.gnssNiCb = [this](uint32_t id, GnssNiNotification gnssNiNotify) { + onGnssNiCb(id, gnssNiNotify); + }; + } } locationCallbacks.gnssSvCb = nullptr; - if (mGnssCbIface != nullptr) { - locationCallbacks.gnssSvCb = [this](GnssSvNotification gnssSvNotification) { - onGnssSvCb(gnssSvNotification); - }; - } + locationCallbacks.gnssSvCb = [this](GnssSvNotification gnssSvNotification) { + onGnssSvCb(gnssSvNotification); + }; locationCallbacks.gnssNmeaCb = nullptr; - if (mGnssCbIface != nullptr) { - locationCallbacks.gnssNmeaCb = [this](GnssNmeaNotification gnssNmeaNotification) { - onGnssNmeaCb(gnssNmeaNotification); - }; - } + locationCallbacks.gnssNmeaCb = [this](GnssNmeaNotification gnssNmeaNotification) { + onGnssNmeaCb(gnssNmeaNotification); + }; locationCallbacks.gnssMeasurementsCb = nullptr; locAPISetCallbacks(locationCallbacks); } +// for GpsInterface +void GnssAPIClient::gnssUpdateCallbacks(const sp& gpsCb, + const sp& niCb) +{ + LOC_LOGD("%s]: (%p %p)", __FUNCTION__, &gpsCb, &niCb); + + mMutex.lock(); + mGnssCbIface = gpsCb; + mGnssNiCbIface = niCb; + mMutex.unlock(); + + if (mGnssCbIface != nullptr || mGnssNiCbIface != nullptr) { + setCallbacks(); + } +} + +void GnssAPIClient::gnssUpdateCallbacks_2_0(const sp& gpsCb) +{ + LOC_LOGD("%s]: (%p)", __FUNCTION__, &gpsCb); + + mMutex.lock(); + mGnssCbIface_2_0 = gpsCb; + mMutex.unlock(); + + if (mGnssCbIface_2_0 != nullptr) { + setCallbacks(); + } +} + bool GnssAPIClient::gnssStart() { LOC_LOGD("%s]: ()", __FUNCTION__); @@ -307,9 +344,10 @@ void GnssAPIClient::onCapabilitiesCb(LocationCapabilitiesMask capabilitiesMask) mMutex.lock(); auto gnssCbIface(mGnssCbIface); + auto gnssCbIface_2_0(mGnssCbIface_2_0); mMutex.unlock(); - if (gnssCbIface != nullptr) { + if (gnssCbIface_2_0 != nullptr || gnssCbIface != nullptr) { uint32_t data = 0; if ((capabilitiesMask & LOCATION_CAPABILITIES_TIME_BASED_TRACKING_BIT) || (capabilitiesMask & LOCATION_CAPABILITIES_TIME_BASED_BATCHING_BIT) || @@ -317,20 +355,18 @@ void GnssAPIClient::onCapabilitiesCb(LocationCapabilitiesMask capabilitiesMask) (capabilitiesMask & LOCATION_CAPABILITIES_DISTANCE_BASED_BATCHING_BIT)) data |= IGnssCallback::Capabilities::SCHEDULING; if (capabilitiesMask & LOCATION_CAPABILITIES_GEOFENCE_BIT) - data |= IGnssCallback::Capabilities::GEOFENCING; + data |= V1_0::IGnssCallback::Capabilities::GEOFENCING; if (capabilitiesMask & LOCATION_CAPABILITIES_GNSS_MEASUREMENTS_BIT) - data |= IGnssCallback::Capabilities::MEASUREMENTS; + data |= V1_0::IGnssCallback::Capabilities::MEASUREMENTS; if (capabilitiesMask & LOCATION_CAPABILITIES_GNSS_MSB_BIT) data |= IGnssCallback::Capabilities::MSB; if (capabilitiesMask & LOCATION_CAPABILITIES_GNSS_MSA_BIT) data |= IGnssCallback::Capabilities::MSA; - auto r = gnssCbIface->gnssSetCapabilitesCb(data); - if (!r.isOk()) { - LOC_LOGE("%s] Error from gnssSetCapabilitesCb description=%s", - __func__, r.description().c_str()); - } - } - if (gnssCbIface != nullptr) { + if (capabilitiesMask & LOCATION_CAPABILITIES_AGPM_BIT) + data |= IGnssCallback::Capabilities::LOW_POWER_MODE; + if (capabilitiesMask & LOCATION_CAPABILITIES_CONSTELLATION_ENABLEMENT_BIT) + data |= IGnssCallback::Capabilities::SATELLITE_BLACKLIST; + IGnssCallback::GnssSystemInfo gnssInfo; if (capabilitiesMask & LOCATION_CAPABILITIES_CONSTELLATION_ENABLEMENT_BIT || capabilitiesMask & LOCATION_CAPABILITIES_AGPM_BIT) { @@ -343,12 +379,33 @@ void GnssAPIClient::onCapabilitiesCb(LocationCapabilitiesMask capabilitiesMask) gnssInfo.yearOfHw = 2015; } LOC_LOGV("%s:%d] set_system_info_cb (%d)", __FUNCTION__, __LINE__, gnssInfo.yearOfHw); - auto r = gnssCbIface->gnssSetSystemInfoCb(gnssInfo); - if (!r.isOk()) { - LOC_LOGE("%s] Error from gnssSetSystemInfoCb description=%s", - __func__, r.description().c_str()); + + if (gnssCbIface_2_0 != nullptr) { + auto r = gnssCbIface_2_0->gnssSetCapabilitiesCb_2_0(data); + if (!r.isOk()) { + LOC_LOGE("%s] Error from gnssSetCapabilitiesCb_2_0 description=%s", + __func__, r.description().c_str()); + } + r = gnssCbIface_2_0->gnssSetSystemInfoCb(gnssInfo); + if (!r.isOk()) { + LOC_LOGE("%s] Error from gnssSetSystemInfoCb description=%s", + __func__, r.description().c_str()); + } + } else if (gnssCbIface != nullptr) { + auto r = gnssCbIface->gnssSetCapabilitesCb(data); + if (!r.isOk()) { + LOC_LOGE("%s] Error from gnssSetCapabilitesCb description=%s", + __func__, r.description().c_str()); + } + r = gnssCbIface->gnssSetSystemInfoCb(gnssInfo); + if (!r.isOk()) { + LOC_LOGE("%s] Error from gnssSetSystemInfoCb description=%s", + __func__, r.description().c_str()); + } } + } + } void GnssAPIClient::onTrackingCb(Location location) @@ -356,17 +413,29 @@ void GnssAPIClient::onTrackingCb(Location location) LOC_LOGD("%s]: (flags: %02x)", __FUNCTION__, location.flags); mMutex.lock(); auto gnssCbIface(mGnssCbIface); + auto gnssCbIface_2_0(mGnssCbIface_2_0); mMutex.unlock(); - if (gnssCbIface != nullptr) { - GnssLocation gnssLocation; + if (gnssCbIface_2_0 != nullptr) { + V2_0::GnssLocation gnssLocation; + convertGnssLocation(location, gnssLocation); + auto r = gnssCbIface_2_0->gnssLocationCb_2_0(gnssLocation); + if (!r.isOk()) { + LOC_LOGE("%s] Error from gnssLocationCb_2_0 description=%s", + __func__, r.description().c_str()); + } + } else if (gnssCbIface != nullptr) { + V1_0::GnssLocation gnssLocation; convertGnssLocation(location, gnssLocation); auto r = gnssCbIface->gnssLocationCb(gnssLocation); if (!r.isOk()) { LOC_LOGE("%s] Error from gnssLocationCb description=%s", __func__, r.description().c_str()); } + } else { + LOC_LOGW("%s] No GNSS Interface ready for gnssLocationCb ", __FUNCTION__); } + } void GnssAPIClient::onGnssNiCb(uint32_t id, GnssNiNotification gnssNiNotification) @@ -449,10 +518,19 @@ void GnssAPIClient::onGnssSvCb(GnssSvNotification gnssSvNotification) LOC_LOGD("%s]: (count: %zu)", __FUNCTION__, gnssSvNotification.count); mMutex.lock(); auto gnssCbIface(mGnssCbIface); + auto gnssCbIface_2_0(mGnssCbIface_2_0); mMutex.unlock(); - if (gnssCbIface != nullptr) { - IGnssCallback::GnssSvStatus svStatus; + if (gnssCbIface_2_0 != nullptr) { + hidl_vec svInfoList; + convertGnssSvStatus(gnssSvNotification, svInfoList); + auto r = gnssCbIface_2_0->gnssSvStatusCb_2_0(svInfoList); + if (!r.isOk()) { + LOC_LOGE("%s] Error from gnssSvStatusCb_2_0 description=%s", + __func__, r.description().c_str()); + } + } else if (gnssCbIface != nullptr) { + V1_0::IGnssCallback::GnssSvStatus svStatus; convertGnssSvStatus(gnssSvNotification, svStatus); auto r = gnssCbIface->gnssSvStatusCb(svStatus); if (!r.isOk()) { @@ -466,9 +544,10 @@ void GnssAPIClient::onGnssNmeaCb(GnssNmeaNotification gnssNmeaNotification) { mMutex.lock(); auto gnssCbIface(mGnssCbIface); + auto gnssCbIface_2_0(mGnssCbIface_2_0); mMutex.unlock(); - if (gnssCbIface != nullptr) { + if (gnssCbIface != nullptr || gnssCbIface_2_0 != nullptr) { const std::string s(gnssNmeaNotification.nmea); std::stringstream ss(s); std::string each; @@ -476,12 +555,22 @@ void GnssAPIClient::onGnssNmeaCb(GnssNmeaNotification gnssNmeaNotification) each += '\n'; android::hardware::hidl_string nmeaString; nmeaString.setToExternal(each.c_str(), each.length()); - auto r = gnssCbIface->gnssNmeaCb( - static_cast(gnssNmeaNotification.timestamp), nmeaString); - if (!r.isOk()) { - LOC_LOGE("%s] Error from gnssNmeaCb nmea=%s length=%zu description=%s", __func__, - gnssNmeaNotification.nmea, gnssNmeaNotification.length, - r.description().c_str()); + if (gnssCbIface_2_0 != nullptr) { + auto r = gnssCbIface_2_0->gnssNmeaCb( + static_cast(gnssNmeaNotification.timestamp), nmeaString); + if (!r.isOk()) { + LOC_LOGE("%s] Error from gnssCbIface_2_0 nmea=%s length=%zu description=%s", + __func__, gnssNmeaNotification.nmea, gnssNmeaNotification.length, + r.description().c_str()); + } + } else if (gnssCbIface != nullptr) { + auto r = gnssCbIface->gnssNmeaCb( + static_cast(gnssNmeaNotification.timestamp), nmeaString); + if (!r.isOk()) { + LOC_LOGE("%s] Error from gnssNmeaCb nmea=%s length=%zu description=%s", + __func__, gnssNmeaNotification.nmea, gnssNmeaNotification.length, + r.description().c_str()); + } } } } @@ -492,18 +581,32 @@ void GnssAPIClient::onStartTrackingCb(LocationError error) LOC_LOGD("%s]: (%d)", __FUNCTION__, error); mMutex.lock(); auto gnssCbIface(mGnssCbIface); + auto gnssCbIface_2_0(mGnssCbIface_2_0); mMutex.unlock(); - if (error == LOCATION_ERROR_SUCCESS && gnssCbIface != nullptr) { - auto r = gnssCbIface->gnssStatusCb(IGnssCallback::GnssStatusValue::ENGINE_ON); - if (!r.isOk()) { - LOC_LOGE("%s] Error from gnssStatusCb ENGINE_ON description=%s", - __func__, r.description().c_str()); - } - r = gnssCbIface->gnssStatusCb(IGnssCallback::GnssStatusValue::SESSION_BEGIN); - if (!r.isOk()) { - LOC_LOGE("%s] Error from gnssStatusCb SESSION_BEGIN description=%s", - __func__, r.description().c_str()); + if (error == LOCATION_ERROR_SUCCESS) { + if (gnssCbIface_2_0 != nullptr) { + auto r = gnssCbIface_2_0->gnssStatusCb(IGnssCallback::GnssStatusValue::ENGINE_ON); + if (!r.isOk()) { + LOC_LOGE("%s] Error from gnssStatusCb 2.0 ENGINE_ON description=%s", + __func__, r.description().c_str()); + } + r = gnssCbIface_2_0->gnssStatusCb(IGnssCallback::GnssStatusValue::SESSION_BEGIN); + if (!r.isOk()) { + LOC_LOGE("%s] Error from gnssStatusCb 2.0 SESSION_BEGIN description=%s", + __func__, r.description().c_str()); + } + } else if (gnssCbIface != nullptr) { + auto r = gnssCbIface->gnssStatusCb(IGnssCallback::GnssStatusValue::ENGINE_ON); + if (!r.isOk()) { + LOC_LOGE("%s] Error from gnssStatusCb ENGINE_ON description=%s", + __func__, r.description().c_str()); + } + r = gnssCbIface->gnssStatusCb(IGnssCallback::GnssStatusValue::SESSION_BEGIN); + if (!r.isOk()) { + LOC_LOGE("%s] Error from gnssStatusCb SESSION_BEGIN description=%s", + __func__, r.description().c_str()); + } } } } @@ -513,23 +616,38 @@ void GnssAPIClient::onStopTrackingCb(LocationError error) LOC_LOGD("%s]: (%d)", __FUNCTION__, error); mMutex.lock(); auto gnssCbIface(mGnssCbIface); + auto gnssCbIface_2_0(mGnssCbIface_2_0); mMutex.unlock(); - if (error == LOCATION_ERROR_SUCCESS && gnssCbIface != nullptr) { - auto r = gnssCbIface->gnssStatusCb(IGnssCallback::GnssStatusValue::SESSION_END); - if (!r.isOk()) { - LOC_LOGE("%s] Error from gnssStatusCb SESSION_END description=%s", - __func__, r.description().c_str()); - } - r = gnssCbIface->gnssStatusCb(IGnssCallback::GnssStatusValue::ENGINE_OFF); - if (!r.isOk()) { - LOC_LOGE("%s] Error from gnssStatusCb ENGINE_OFF description=%s", - __func__, r.description().c_str()); + if (error == LOCATION_ERROR_SUCCESS) { + if (gnssCbIface_2_0 != nullptr) { + auto r = gnssCbIface_2_0->gnssStatusCb(IGnssCallback::GnssStatusValue::SESSION_END); + if (!r.isOk()) { + LOC_LOGE("%s] Error from gnssStatusCb 2.0 SESSION_END description=%s", + __func__, r.description().c_str()); + } + r = gnssCbIface_2_0->gnssStatusCb(IGnssCallback::GnssStatusValue::ENGINE_OFF); + if (!r.isOk()) { + LOC_LOGE("%s] Error from gnssStatusCb 2.0 ENGINE_OFF description=%s", + __func__, r.description().c_str()); + } + + } else if (gnssCbIface != nullptr) { + auto r = gnssCbIface->gnssStatusCb(IGnssCallback::GnssStatusValue::SESSION_END); + if (!r.isOk()) { + LOC_LOGE("%s] Error from gnssStatusCb SESSION_END description=%s", + __func__, r.description().c_str()); + } + r = gnssCbIface->gnssStatusCb(IGnssCallback::GnssStatusValue::ENGINE_OFF); + if (!r.isOk()) { + LOC_LOGE("%s] Error from gnssStatusCb ENGINE_OFF description=%s", + __func__, r.description().c_str()); + } } } } -static void convertGnssSvStatus(GnssSvNotification& in, IGnssCallback::GnssSvStatus& out) +static void convertGnssSvStatus(GnssSvNotification& in, V1_0::IGnssCallback::GnssSvStatus& out) { memset(&out, 0, sizeof(IGnssCallback::GnssSvStatus)); out.numSvs = in.count; @@ -539,22 +657,45 @@ static void convertGnssSvStatus(GnssSvNotification& in, IGnssCallback::GnssSvSta out.numSvs = static_cast(V1_0::GnssMax::SVS_COUNT); } for (size_t i = 0; i < out.numSvs; i++) { - IGnssCallback::GnssSvInfo& info = out.gnssSvList[i]; - info.svid = in.gnssSvs[i].svId; - convertGnssConstellationType(in.gnssSvs[i].type, info.constellation); - info.cN0Dbhz = in.gnssSvs[i].cN0Dbhz; - info.elevationDegrees = in.gnssSvs[i].elevation; - info.azimuthDegrees = in.gnssSvs[i].azimuth; - info.carrierFrequencyHz = in.gnssSvs[i].carrierFrequencyHz; - info.svFlag = static_cast(IGnssCallback::GnssSvFlags::NONE); + out.gnssSvList[i].svid = in.gnssSvs[i].svId; + convertGnssConstellationType(in.gnssSvs[i].type, out.gnssSvList[i].constellation); + out.gnssSvList[i].cN0Dbhz = in.gnssSvs[i].cN0Dbhz; + out.gnssSvList[i].elevationDegrees = in.gnssSvs[i].elevation; + out.gnssSvList[i].azimuthDegrees = in.gnssSvs[i].azimuth; + out.gnssSvList[i].carrierFrequencyHz = in.gnssSvs[i].carrierFrequencyHz; + out.gnssSvList[i].svFlag = static_cast(IGnssCallback::GnssSvFlags::NONE); if (in.gnssSvs[i].gnssSvOptionsMask & GNSS_SV_OPTIONS_HAS_EPHEMER_BIT) - info.svFlag |= IGnssCallback::GnssSvFlags::HAS_EPHEMERIS_DATA; + out.gnssSvList[i].svFlag |= IGnssCallback::GnssSvFlags::HAS_EPHEMERIS_DATA; if (in.gnssSvs[i].gnssSvOptionsMask & GNSS_SV_OPTIONS_HAS_ALMANAC_BIT) - info.svFlag |= IGnssCallback::GnssSvFlags::HAS_ALMANAC_DATA; + out.gnssSvList[i].svFlag |= IGnssCallback::GnssSvFlags::HAS_ALMANAC_DATA; if (in.gnssSvs[i].gnssSvOptionsMask & GNSS_SV_OPTIONS_USED_IN_FIX_BIT) - info.svFlag |= IGnssCallback::GnssSvFlags::USED_IN_FIX; + out.gnssSvList[i].svFlag |= IGnssCallback::GnssSvFlags::USED_IN_FIX; if (in.gnssSvs[i].gnssSvOptionsMask & GNSS_SV_OPTIONS_HAS_CARRIER_FREQUENCY_BIT) - info.svFlag |= IGnssCallback::GnssSvFlags::HAS_CARRIER_FREQUENCY; + out.gnssSvList[i].svFlag |= IGnssCallback::GnssSvFlags::HAS_CARRIER_FREQUENCY; + } +} + +static void convertGnssSvStatus(GnssSvNotification& in, + hidl_vec& out) +{ + out.resize(in.count); + for (size_t i = 0; i < in.count; i++) { + out[i].v1_0.svid = in.gnssSvs[i].svId; + out[i].v1_0.cN0Dbhz = in.gnssSvs[i].cN0Dbhz; + out[i].v1_0.elevationDegrees = in.gnssSvs[i].elevation; + out[i].v1_0.azimuthDegrees = in.gnssSvs[i].azimuth; + out[i].v1_0.carrierFrequencyHz = in.gnssSvs[i].carrierFrequencyHz; + out[i].v1_0.svFlag = static_cast(IGnssCallback::GnssSvFlags::NONE); + if (in.gnssSvs[i].gnssSvOptionsMask & GNSS_SV_OPTIONS_HAS_EPHEMER_BIT) + out[i].v1_0.svFlag |= IGnssCallback::GnssSvFlags::HAS_EPHEMERIS_DATA; + if (in.gnssSvs[i].gnssSvOptionsMask & GNSS_SV_OPTIONS_HAS_ALMANAC_BIT) + out[i].v1_0.svFlag |= IGnssCallback::GnssSvFlags::HAS_ALMANAC_DATA; + if (in.gnssSvs[i].gnssSvOptionsMask & GNSS_SV_OPTIONS_USED_IN_FIX_BIT) + out[i].v1_0.svFlag |= IGnssCallback::GnssSvFlags::USED_IN_FIX; + if (in.gnssSvs[i].gnssSvOptionsMask & GNSS_SV_OPTIONS_HAS_CARRIER_FREQUENCY_BIT) + out[i].v1_0.svFlag |= IGnssCallback::GnssSvFlags::HAS_CARRIER_FREQUENCY; + + convertGnssConstellationType(in.gnssSvs[i].type, out[i].constellation); } } diff --git a/android/2.0/location_api/GnssAPIClient.h b/android/2.0/location_api/GnssAPIClient.h index a129cee..493f9ca 100644 --- a/android/2.0/location_api/GnssAPIClient.h +++ b/android/2.0/location_api/GnssAPIClient.h @@ -33,7 +33,7 @@ #include #include -//#include +#include #include namespace android { @@ -49,6 +49,7 @@ class GnssAPIClient : public LocationAPIClientBase public: GnssAPIClient(const sp& gpsCb, const sp& niCb); + GnssAPIClient(const sp& gpsCb); virtual ~GnssAPIClient(); GnssAPIClient(const GnssAPIClient&) = delete; GnssAPIClient& operator=(const GnssAPIClient&) = delete; @@ -56,6 +57,7 @@ public: // for GpsInterface void gnssUpdateCallbacks(const sp& gpsCb, const sp& niCb); + void gnssUpdateCallbacks_2_0(const sp& gpsCb); bool gnssStart(); bool gnssStop(); bool gnssSetPositionMode(V1_0::IGnss::GnssPositionMode mode, @@ -91,6 +93,8 @@ public: void onStopTrackingCb(LocationError error) final; private: + void setCallbacks(); + void initLocationOptions(); sp mGnssCbIface; sp mGnssNiCbIface; std::mutex mMutex; @@ -98,6 +102,7 @@ private: LocationCapabilitiesMask mLocationCapabilitiesMask; bool mLocationCapabilitiesCached; TrackingOptions mTrackingOptions; + sp mGnssCbIface_2_0; }; } // namespace implementation diff --git a/android/2.0/location_api/LocationUtil.cpp b/android/2.0/location_api/LocationUtil.cpp index c921154..6bd5084 100644 --- a/android/2.0/location_api/LocationUtil.cpp +++ b/android/2.0/location_api/LocationUtil.cpp @@ -28,6 +28,8 @@ */ #include +#include +#include namespace android { namespace hardware { @@ -35,13 +37,13 @@ namespace gnss { namespace V2_0 { namespace implementation { -using ::android::hardware::gnss::V1_0::GnssLocation; -using ::android::hardware::gnss::V1_0::GnssConstellationType; +using ::android::hardware::gnss::V2_0::GnssLocation; +using ::android::hardware::gnss::V2_0::GnssConstellationType; using ::android::hardware::gnss::V1_0::GnssLocationFlags; -void convertGnssLocation(Location& in, GnssLocation& out) +void convertGnssLocation(Location& in, V1_0::GnssLocation& out) { - memset(&out, 0, sizeof(GnssLocation)); + memset(&out, 0, sizeof(V1_0::GnssLocation)); if (in.flags & LOCATION_HAS_LAT_LONG_BIT) { out.gnssLocationFlags |= GnssLocationFlags::HAS_LAT_LONG; out.latitudeDegrees = in.latitude; @@ -79,7 +81,40 @@ void convertGnssLocation(Location& in, GnssLocation& out) out.timestamp = static_cast(in.timestamp); } -void convertGnssLocation(const GnssLocation& in, Location& out) +void convertGnssLocation(Location& in, V2_0::GnssLocation& out) +{ + memset(&out, 0, sizeof(V2_0::GnssLocation)); + convertGnssLocation(in, out.v1_0); + + struct timespec sinceBootTime; + struct timespec currentTime; + if (0 == clock_gettime(CLOCK_BOOTTIME,&sinceBootTime) && + 0 == clock_gettime(CLOCK_REALTIME,¤tTime)) { + + int64_t sinceBootTimeNanos = sinceBootTime.tv_sec*1000000000 + sinceBootTime.tv_nsec; + int64_t currentTimeNanos = currentTime.tv_sec*1000000000 + currentTime.tv_nsec; + int64_t locationTimeNanos = in.timestamp*1000000; + LOC_LOGD("%s]: sinceBootTimeNanos:%" PRIi64 " currentTimeNanos:%" PRIi64 "" + " locationTimeNanos:%" PRIi64 "", + __FUNCTION__, sinceBootTimeNanos, currentTimeNanos, locationTimeNanos); + if (currentTimeNanos >= locationTimeNanos) { + int64_t ageTimeNanos = currentTimeNanos - locationTimeNanos; + LOC_LOGD("%s]: ageTimeNanos:%" PRIi64 ")", __FUNCTION__, ageTimeNanos); + if (ageTimeNanos >= 0 && ageTimeNanos <= sinceBootTimeNanos) { + 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; + LOC_LOGD("%s]: timestampNs:%" PRIi64 ")", + __FUNCTION__, out.elapsedRealtime.timestampNs); + } + } + } + +} + +void convertGnssLocation(const V1_0::GnssLocation& in, Location& out) { memset(&out, 0, sizeof(out)); if (in.gnssLocationFlags & GnssLocationFlags::HAS_LAT_LONG) { @@ -119,30 +154,64 @@ void convertGnssLocation(const GnssLocation& in, Location& out) out.timestamp = static_cast(in.timestamp); } -void convertGnssConstellationType(GnssSvType& in, GnssConstellationType& out) +void convertGnssLocation(const V2_0::GnssLocation& in, Location& out) +{ + memset(&out, 0, sizeof(out)); + convertGnssLocation(in.v1_0, out); +} + +void convertGnssConstellationType(GnssSvType& in, V1_0::GnssConstellationType& out) +{ + switch(in) { + case GNSS_SV_TYPE_GPS: + out = V1_0::GnssConstellationType::GPS; + break; + case GNSS_SV_TYPE_SBAS: + out = V1_0::GnssConstellationType::SBAS; + break; + case GNSS_SV_TYPE_GLONASS: + out = V1_0::GnssConstellationType::GLONASS; + break; + case GNSS_SV_TYPE_QZSS: + out = V1_0::GnssConstellationType::QZSS; + break; + case GNSS_SV_TYPE_BEIDOU: + out = V1_0::GnssConstellationType::BEIDOU; + break; + case GNSS_SV_TYPE_GALILEO: + out = V1_0::GnssConstellationType::GALILEO; + break; + case GNSS_SV_TYPE_UNKNOWN: + default: + out = V1_0::GnssConstellationType::UNKNOWN; + break; + } +} + +void convertGnssConstellationType(GnssSvType& in, V2_0::GnssConstellationType& out) { switch(in) { case GNSS_SV_TYPE_GPS: - out = GnssConstellationType::GPS; + out = V2_0::GnssConstellationType::GPS; break; case GNSS_SV_TYPE_SBAS: - out = GnssConstellationType::SBAS; + out = V2_0::GnssConstellationType::SBAS; break; case GNSS_SV_TYPE_GLONASS: - out = GnssConstellationType::GLONASS; + out = V2_0::GnssConstellationType::GLONASS; break; case GNSS_SV_TYPE_QZSS: - out = GnssConstellationType::QZSS; + out = V2_0::GnssConstellationType::QZSS; break; case GNSS_SV_TYPE_BEIDOU: - out = GnssConstellationType::BEIDOU; + out = V2_0::GnssConstellationType::BEIDOU; break; case GNSS_SV_TYPE_GALILEO: - out = GnssConstellationType::GALILEO; + out = V2_0::GnssConstellationType::GALILEO; break; case GNSS_SV_TYPE_UNKNOWN: default: - out = GnssConstellationType::UNKNOWN; + out = V2_0::GnssConstellationType::UNKNOWN; break; } } diff --git a/android/2.0/location_api/LocationUtil.h b/android/2.0/location_api/LocationUtil.h index c6f5ead..8426de7 100644 --- a/android/2.0/location_api/LocationUtil.h +++ b/android/2.0/location_api/LocationUtil.h @@ -30,7 +30,7 @@ #ifndef LOCATION_UTIL_H #define LOCATION_UTIL_H -#include +#include #include #include @@ -41,8 +41,11 @@ namespace V2_0 { namespace implementation { void convertGnssLocation(Location& in, V1_0::GnssLocation& out); +void convertGnssLocation(Location& in, V2_0::GnssLocation& out); void convertGnssLocation(const V1_0::GnssLocation& in, Location& out); +void convertGnssLocation(const V2_0::GnssLocation& in, Location& out); void convertGnssConstellationType(GnssSvType& in, V1_0::GnssConstellationType& out); +void convertGnssConstellationType(GnssSvType& in, V2_0::GnssConstellationType& out); void convertGnssEphemerisType(GnssEphemerisType& in, GnssDebug::SatelliteEphemerisType& out); void convertGnssEphemerisSource(GnssEphemerisSource& in, GnssDebug::SatelliteEphemerisSource& out); void convertGnssEphemerisHealth(GnssEphemerisHealth& in, GnssDebug::SatelliteEphemerisHealth& out); diff --git a/android/2.0/location_api/MeasurementAPIClient.cpp b/android/2.0/location_api/MeasurementAPIClient.cpp index d9cae18..23c3b16 100644 --- a/android/2.0/location_api/MeasurementAPIClient.cpp +++ b/android/2.0/location_api/MeasurementAPIClient.cpp @@ -54,6 +54,8 @@ static void convertGnssData_2_0(GnssMeasurementsNotification& in, static void convertGnssMeasurement(GnssMeasurementsData& in, V1_0::IGnssMeasurementCallback::GnssMeasurement& out); static void convertGnssClock(GnssMeasurementsClock& in, IGnssMeasurementCallback::GnssClock& out); +static void convertGnssMeasurementsCodeType(GnssMeasurementsCodeType& in, + ::android::hardware::hidl_string& out); MeasurementAPIClient::MeasurementAPIClient() : mGnssMeasurementCbIface(nullptr), @@ -362,6 +364,8 @@ static void convertGnssData_2_0(GnssMeasurementsNotification& in, 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); + convertGnssConstellationType(in.measurements[i].svType, out.measurements[i].constellation); + convertGnssMeasurementsCodeType(in.measurements[i].codeType, out.measurements[i].codeType); if (in.measurements[i].adrStateMask & GNSS_MEASUREMENTS_ACCUMULATED_DELTA_RANGE_STATE_VALID_BIT) out.measurements[i].v1_1.accumulatedDeltaRangeState |= IGnssMeasurementCallback::GnssAccumulatedDeltaRangeState::ADR_STATE_VALID; @@ -374,11 +378,6 @@ static void convertGnssData_2_0(GnssMeasurementsNotification& in, if (in.measurements[i].adrStateMask & GNSS_MEASUREMENTS_ACCUMULATED_DELTA_RANGE_STATE_HALF_CYCLE_RESOLVED_BIT) out.measurements[i].v1_1.accumulatedDeltaRangeState |= IGnssMeasurementCallback::GnssAccumulatedDeltaRangeState::ADR_STATE_HALF_CYCLE_RESOLVED; - -// out.measurements[i].codeType = -// static_cast(in.measurements[i].codeType); -// out.measurements[i].otherCodeTypeName = in.measurements[i].otherCodeTypeName; - if (in.measurements[i].stateMask & GNSS_MEASUREMENTS_STATE_CODE_LOCK_BIT) out.measurements[i].state |= IGnssMeasurementCallback::GnssMeasurementState::STATE_CODE_LOCK; if (in.measurements[i].stateMask & GNSS_MEASUREMENTS_STATE_BIT_SYNC_BIT) @@ -417,6 +416,57 @@ static void convertGnssData_2_0(GnssMeasurementsNotification& in, convertGnssClock(in.clock, out.clock); } +static void convertGnssMeasurementsCodeType(GnssMeasurementsCodeType& in, + ::android::hardware::hidl_string& out) +{ + switch(in) { + case GNSS_MEASUREMENTS_CODE_TYPE_A: + out = "A"; + break; + case GNSS_MEASUREMENTS_CODE_TYPE_B: + out = "B"; + break; + case GNSS_MEASUREMENTS_CODE_TYPE_C: + out = "C"; + break; + case GNSS_MEASUREMENTS_CODE_TYPE_I: + out = "I"; + break; + case GNSS_MEASUREMENTS_CODE_TYPE_L: + out = "L"; + break; + case GNSS_MEASUREMENTS_CODE_TYPE_M: + out = "M"; + break; + case GNSS_MEASUREMENTS_CODE_TYPE_P: + out = "P"; + break; + case GNSS_MEASUREMENTS_CODE_TYPE_Q: + out = "Q"; + break; + case GNSS_MEASUREMENTS_CODE_TYPE_S: + out = "S"; + break; + case GNSS_MEASUREMENTS_CODE_TYPE_W: + out = "W"; + break; + case GNSS_MEASUREMENTS_CODE_TYPE_X: + out = "X"; + break; + case GNSS_MEASUREMENTS_CODE_TYPE_Y: + out = "Y"; + break; + case GNSS_MEASUREMENTS_CODE_TYPE_Z: + out = "Z"; + break; + case GNSS_MEASUREMENTS_CODE_TYPE_N: + out = "N"; + break; + default: + out = "UNKNOWN"; + } +} + } // namespace implementation } // namespace V2_0 } // namespace gnss diff --git a/android/measurement_corrections/1.0/MeasurementCorrections.cpp b/android/measurement_corrections/1.0/MeasurementCorrections.cpp index c1a335a..2c93cb3 100644 --- a/android/measurement_corrections/1.0/MeasurementCorrections.cpp +++ b/android/measurement_corrections/1.0/MeasurementCorrections.cpp @@ -54,11 +54,12 @@ MeasurementCorrections::MeasurementCorrections() { MeasurementCorrections::~MeasurementCorrections() { } -Return MeasurementCorrections::setCorrections(const ::android::hardware::gnss::measurement_corrections::V1_0::MeasurementCorrections& corrections) { +Return MeasurementCorrections::setCorrections(const ::android::hardware::gnss::measurement_corrections::V1_0::MeasurementCorrections& /*corrections*/) { return true; } -Return MeasurementCorrections::setCallback(const sp& callback) { +Return MeasurementCorrections::setCallback( + const sp& /*callback*/) { return true; } -- cgit v1.2.3