From cd1031a520ec204990a00ce2bc4f55a6130f7c93 Mon Sep 17 00:00:00 2001 From: Mike Cailean Date: Thu, 18 Apr 2019 12:57:11 -0700 Subject: Update proxyAppPackageName field in nfw notification Change-Id: I993a6d9227b03626bc254675944df28cc578a6c7 CRs-fixed: 2437418 --- core/ContextBase.cpp | 1 + core/ContextBase.h | 1 + etc/gps.conf | 7 +++++++ utils/gps_extended_c.h | 3 ++- 4 files changed, 11 insertions(+), 1 deletion(-) diff --git a/core/ContextBase.cpp b/core/ContextBase.cpp index 28109bb..9650701 100644 --- a/core/ContextBase.cpp +++ b/core/ContextBase.cpp @@ -78,6 +78,7 @@ const loc_param_s_type ContextBase::mGps_conf_table[] = {"CONSTRAINED_TIME_UNCERTAINTY_THRESHOLD", &mGps_conf.CONSTRAINED_TIME_UNCERTAINTY_THRESHOLD, NULL, 'f'}, {"CONSTRAINED_TIME_UNCERTAINTY_ENERGY_BUDGET", &mGps_conf.CONSTRAINED_TIME_UNCERTAINTY_ENERGY_BUDGET, NULL, 'n'}, {"POSITION_ASSISTED_CLOCK_ESTIMATOR_ENABLED", &mGps_conf.POSITION_ASSISTED_CLOCK_ESTIMATOR_ENABLED, NULL, 'n'}, + {"PROXY_APP_PACKAGE_NAME", &mGps_conf.PROXY_APP_PACKAGE_NAME, NULL, 's' }, }; const loc_param_s_type ContextBase::mSap_conf_table[] = diff --git a/core/ContextBase.h b/core/ContextBase.h index 9c72835..8fc2bd5 100644 --- a/core/ContextBase.h +++ b/core/ContextBase.h @@ -71,6 +71,7 @@ typedef struct loc_gps_cfg_s double CONSTRAINED_TIME_UNCERTAINTY_THRESHOLD; uint32_t CONSTRAINED_TIME_UNCERTAINTY_ENERGY_BUDGET; uint32_t POSITION_ASSISTED_CLOCK_ESTIMATOR_ENABLED; + char PROXY_APP_PACKAGE_NAME[LOC_MAX_PARAM_STRING]; } loc_gps_cfg_s_type; /* NOTE: the implementaiton of the parser casts number diff --git a/etc/gps.conf b/etc/gps.conf index a5dabb2..f1cf84d 100644 --- a/etc/gps.conf +++ b/etc/gps.conf @@ -281,3 +281,10 @@ MODEM_TYPE = 1 # SV is available and the UE’s position is known by # other position engines. #POSITION_ASSISTED_CLOCK_ESTIMATOR_ENABLED = 0 + +##################################### +# proxyAppPackageName +##################################### +# This is a string that is sent to the framework +# in nfwNotifyCb callback +PROXY_APP_PACKAGE_NAME = com.google.android.carrierlocation diff --git a/utils/gps_extended_c.h b/utils/gps_extended_c.h index 242fe84..279fa20 100644 --- a/utils/gps_extended_c.h +++ b/utils/gps_extended_c.h @@ -2052,6 +2052,7 @@ struct AGnssExtStatusIpV6 { /* * Represents the the Nfw Notification structure */ +#define GNSS_MAX_NFW_APP_STRING_LEN 64 #define GNSS_MAX_NFW_STRING_LEN 20 typedef enum { @@ -2079,7 +2080,7 @@ typedef enum { } GnssNfwResponseType; typedef struct { - char proxyAppPackageName[GNSS_MAX_NFW_STRING_LEN]; + char proxyAppPackageName[GNSS_MAX_NFW_APP_STRING_LEN]; GnssNfwProtocolStack protocolStack; char otherProtocolStackName[GNSS_MAX_NFW_STRING_LEN]; GnssNfwRequestor requestor; -- cgit v1.2.3 From 0802cf66449eb39bad120787f219edb000cac20f Mon Sep 17 00:00:00 2001 From: Nilesh Gharde Date: Tue, 23 Apr 2019 15:13:15 +0530 Subject: LTE Positioning Profile is not reflecting properly Added the GNSS_CONFIG_FLAGS_LPP_PROFILE_VALID_BIT flag. So that the NV value of LPP profile provided in gps.conf can be refelected to modem. Change-Id: I6429a4a79cb83d5991c8a1328ab5daa4ef49619a CRs-fixed: 2439533 --- gnss/GnssAdapter.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/gnss/GnssAdapter.cpp b/gnss/GnssAdapter.cpp index 3563ed0..2039465 100644 --- a/gnss/GnssAdapter.cpp +++ b/gnss/GnssAdapter.cpp @@ -687,7 +687,8 @@ GnssAdapter::setConfigCommand() if (gpsConf.AGPS_CONFIG_INJECT) { gnssConfigRequested.flags |= GNSS_CONFIG_FLAGS_SET_ASSISTANCE_DATA_VALID_BIT | GNSS_CONFIG_FLAGS_SUPL_VERSION_VALID_BIT | - GNSS_CONFIG_FLAGS_AGLONASS_POSITION_PROTOCOL_VALID_BIT; + GNSS_CONFIG_FLAGS_AGLONASS_POSITION_PROTOCOL_VALID_BIT | + GNSS_CONFIG_FLAGS_LPP_PROFILE_VALID_BIT; gnssConfigRequested.suplVersion = adapter.mLocApi->convertSuplVersion(gpsConf.SUPL_VER); gnssConfigRequested.lppProfile = -- cgit v1.2.3 From 27198a21021dd6f47d9b118c1bfdab3dca70a691 Mon Sep 17 00:00:00 2001 From: Mike Cailean Date: Wed, 17 Apr 2019 11:23:56 -0700 Subject: ApnTypeMask is not returned when USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL CRs-fixed: 2437315 Change-Id: If042451e94a651dafb542cdad9d419f08c85ba56 --- gnss/Agps.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/gnss/Agps.cpp b/gnss/Agps.cpp index 9de1329..7931d0c 100644 --- a/gnss/Agps.cpp +++ b/gnss/Agps.cpp @@ -1,4 +1,4 @@ -/* Copyright (c) 2012-2018, The Linux Foundation. All rights reserved. +/* Copyright (c) 2012-2019, 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 @@ -562,6 +562,7 @@ void AgpsManager::requestATL(int connHandle, AGpsExtType agpsType, LOC_AGPS_TYPE_SUPL_ES == agpsType) { agpsType = LOC_AGPS_TYPE_SUPL; apnTypeMask &= ~LOC_APN_TYPE_MASK_EMERGENCY; + apnTypeMask |= LOC_APN_TYPE_MASK_SUPL; LOC_LOGD("Changed agpsType to non-emergency when USE_EMERGENCY... is 0" "and removed LOC_APN_TYPE_MASK_EMERGENCY from apnTypeMask" "agpsType 0x%X apnTypeMask : 0x%X", -- cgit v1.2.3 From 9d0d8e3c7294dac72a2db83b9bcd9185dd53e057 Mon Sep 17 00:00:00 2001 From: Dante Russo Date: Thu, 25 Apr 2019 15:27:40 -0700 Subject: Default value of SUPL_ES to enable SUPL_ES by default needs to be enabled, since it is no longer set by AFW at runtime. CRs-fixed: 2444734 Change-Id: I370a3e0f8ab6905b47629c4076f645b26ff8acc9 --- core/ContextBase.cpp | 2 +- etc/gps.conf | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/core/ContextBase.cpp b/core/ContextBase.cpp index 28109bb..f046baa 100644 --- a/core/ContextBase.cpp +++ b/core/ContextBase.cpp @@ -111,7 +111,7 @@ void ContextBase::readConfig() mGps_conf.GPS_LOCK = GNSS_CONFIG_GPS_LOCK_MO_AND_NI; mGps_conf.SUPL_VER = 0x10000; mGps_conf.SUPL_MODE = 0x1; - mGps_conf.SUPL_ES = 0; + mGps_conf.SUPL_ES = 1; mGps_conf.SUPL_HOST[0] = 0; mGps_conf.SUPL_PORT = 0; mGps_conf.CAPABILITIES = 0x7; diff --git a/etc/gps.conf b/etc/gps.conf index a5dabb2..577c7b0 100644 --- a/etc/gps.conf +++ b/etc/gps.conf @@ -35,7 +35,7 @@ INTERMEDIATE_POS=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 -- cgit v1.2.3 From 6f1fd95a2030be43309e3601499722c78cf0660b Mon Sep 17 00:00:00 2001 From: Deepthi Gunturi Date: Mon, 22 Apr 2019 14:31:47 +0530 Subject: Initial target definition for atoll Change-Id: I6d997cb20da93a407b4948c97723d2ae97f70f6a CRs-Fixed: 2441728 --- build/target_specific_features.mk | 1 + 1 file changed, 1 insertion(+) diff --git a/build/target_specific_features.mk b/build/target_specific_features.mk index 2e74aff..83f3cdd 100644 --- a/build/target_specific_features.mk +++ b/build/target_specific_features.mk @@ -42,6 +42,7 @@ GNSS_HIDL_2_0_TARGET_LIST += msmnile GNSS_HIDL_2_0_TARGET_LIST += $(MSMSTEPPE) GNSS_HIDL_2_0_TARGET_LIST += $(TRINKET) GNSS_HIDL_2_0_TARGET_LIST += kona +GNSS_HIDL_2_0_TARGET_LIST += atoll ifneq (,$(filter $(GNSS_HIDL_2_0_TARGET_LIST),$(TARGET_BOARD_PLATFORM))) GNSS_HIDL_VERSION = 2.0 -- cgit v1.2.3 From d6d55a4948301d76a8489a5a166acd1b1385e4a1 Mon Sep 17 00:00:00 2001 From: Mike Cailean Date: Wed, 24 Apr 2019 11:33:20 -0700 Subject: Send SUPL notification to the framework for E911 sessions only (older modems) Change-Id: Icd317f6e4b042c31afc63011596689d5fb35135f CRs-fixed: 2441292 --- .../1.0/GnssVisibilityControl.cpp | 24 ++++++++++++++++++++++ .../visibility_control/1.0/GnssVisibilityControl.h | 2 ++ gnss/GnssAdapter.cpp | 22 +++++++++++++++++--- gnss/GnssAdapter.h | 8 ++++++++ utils/gps_extended_c.h | 1 + 5 files changed, 54 insertions(+), 3 deletions(-) diff --git a/android/visibility_control/1.0/GnssVisibilityControl.cpp b/android/visibility_control/1.0/GnssVisibilityControl.cpp index 82e465c..5a8c697 100644 --- a/android/visibility_control/1.0/GnssVisibilityControl.cpp +++ b/android/visibility_control/1.0/GnssVisibilityControl.cpp @@ -66,6 +66,13 @@ void GnssVisibilityControl::nfwStatusCb(GnssNfwNotification notification) { } } +bool GnssVisibilityControl::isInEmergencySession() { + if (nullptr != spGnssVisibilityControl) { + return spGnssVisibilityControl->isE911Session(); + } + return false; +} + static void convertGnssNfwNotification(GnssNfwNotification& in, IGnssVisibilityControlCallback::NfwNotification& out) { @@ -97,6 +104,22 @@ void GnssVisibilityControl::statusCb(GnssNfwNotification notification) { } } +bool GnssVisibilityControl::isE911Session() { + + if (mGnssVisibilityControlCbIface != nullptr) { + auto r = mGnssVisibilityControlCbIface->isInEmergencySession(); + if (!r.isOk()) { + LOC_LOGw("Error invoking NFW status cb %s", r.description().c_str()); + return false; + } else { + return (r); + } + } else { + LOC_LOGw("setCallback has not been called yet"); + return false; + } +} + // Methods from ::android::hardware::gnss::visibility_control::V1_0::IGnssVisibilityControl follow. Return GnssVisibilityControl::enableNfwLocationAccess(const hidl_vec<::android::hardware::hidl_string>& proxyApps) { @@ -131,6 +154,7 @@ Return GnssVisibilityControl::setCallback(const ::android::sp<::android::h NfwCbInfo cbInfo = {}; cbInfo.visibilityControlCb = (void*)nfwStatusCb; + cbInfo.isInEmergencySession = (void*)isInEmergencySession; mGnss->getGnssInterface()->nfwInit(cbInfo); diff --git a/android/visibility_control/1.0/GnssVisibilityControl.h b/android/visibility_control/1.0/GnssVisibilityControl.h index 4eaea51..9c26e38 100644 --- a/android/visibility_control/1.0/GnssVisibilityControl.h +++ b/android/visibility_control/1.0/GnssVisibilityControl.h @@ -68,9 +68,11 @@ struct GnssVisibilityControl : public IGnssVisibilityControl { Return setCallback(const ::android::sp<::android::hardware::gnss::visibility_control::V1_0::IGnssVisibilityControlCallback>& callback) override; void statusCb(GnssNfwNotification notification); + bool isE911Session(); /* Data call setup callback passed down to GNSS HAL implementation */ static void nfwStatusCb(GnssNfwNotification notification); + static bool isInEmergencySession(); private: Gnss* mGnss = nullptr; diff --git a/gnss/GnssAdapter.cpp b/gnss/GnssAdapter.cpp index 2039465..fe0fc9b 100644 --- a/gnss/GnssAdapter.cpp +++ b/gnss/GnssAdapter.cpp @@ -94,7 +94,8 @@ GnssAdapter::GnssAdapter() : mPowerOn(false), mAllowFlpNetworkFixes(0), mGnssEnergyConsumedCb(nullptr), - mPowerStateCb(nullptr) + mPowerStateCb(nullptr), + mIsE911Session(NULL) { LOC_LOGD("%s]: Constructor %p", __func__, this); mLocPositionMode.mode = LOC_POSITION_MODE_INVALID; @@ -3367,21 +3368,36 @@ GnssAdapter::requestNiNotifyEvent(const GnssNiNotification ¬ify, const void* struct MsgReportNiNotify : public LocMsg { GnssAdapter& mAdapter; + LocApiBase& mApi; const GnssNiNotification mNotify; const void* mData; inline MsgReportNiNotify(GnssAdapter& adapter, + LocApiBase& api, const GnssNiNotification& notify, const void* data) : LocMsg(), mAdapter(adapter), + mApi(api), mNotify(notify), mData(data) {} inline virtual void proc() const { - mAdapter.requestNiNotify(mNotify, mData); + if (GNSS_NI_TYPE_EMERGENCY_SUPL == mNotify.type || + GNSS_NI_TYPE_CONTROL_PLANE == mNotify.type) { + if (mAdapter.getE911State() || + ((GNSS_CONFIG_SUPL_EMERGENCY_SERVICES_NO == ContextBase::mGps_conf.SUPL_ES) && + (GNSS_NI_TYPE_EMERGENCY_SUPL == mNotify.type))) { + mApi.informNiResponse(GNSS_NI_RESPONSE_ACCEPT, mData); + } + else { + mApi.informNiResponse(GNSS_NI_RESPONSE_DENY, mData); + } + } else { + mAdapter.requestNiNotify(mNotify, mData); + } } }; - sendMsg(new MsgReportNiNotify(*this, notify, data)); + sendMsg(new MsgReportNiNotify(*this, *mLocApi, notify, data)); return true; } diff --git a/gnss/GnssAdapter.h b/gnss/GnssAdapter.h index 9720ba4..7b73ec1 100644 --- a/gnss/GnssAdapter.h +++ b/gnss/GnssAdapter.h @@ -165,8 +165,10 @@ class GnssAdapter : public LocAdapterBase { /* ==== NFW =========================================================================== */ NfwStatusCb mNfwCb; + IsInEmergencySession mIsE911Session; inline void initNfw(const NfwCbInfo& cbInfo) { mNfwCb = (NfwStatusCb)cbInfo.visibilityControlCb; + mIsE911Session = (IsInEmergencySession)cbInfo.isInEmergencySession; } /* ==== ODCPI ========================================================================== */ @@ -396,6 +398,12 @@ public: mNfwCb(notification); } } + inline bool getE911State(void) { + if (NULL != mIsE911Session) { + return mIsE911Session(); + } + return false; + } /*======== GNSSDEBUG ================================================================*/ bool getDebugReport(GnssDebugReport& report); diff --git a/utils/gps_extended_c.h b/utils/gps_extended_c.h index 279fa20..1851783 100644 --- a/utils/gps_extended_c.h +++ b/utils/gps_extended_c.h @@ -2115,6 +2115,7 @@ typedef void (*AgnssStatusIpV4Cb)(AGnssExtStatusIpV4 status); * Callback with NFW information. */ typedef void(*NfwStatusCb)(GnssNfwNotification notification); +typedef bool(*IsInEmergencySession)(void); /* * Callback with AGNSS(IpV6) status information. -- cgit v1.2.3 From 0330e79d4a87db7e1ee358f0e87a49d34c8f3690 Mon Sep 17 00:00:00 2001 From: Wei Chen Date: Fri, 29 Mar 2019 16:59:07 -0700 Subject: Gnss adapter: fill in proper std deviation in position report The north and east standard deviation fields are not filled in properly in position report Change-Id: Ic243a6862f3fa4e723b507d391c9a904d65d3c30 CRs-fixed: 2426344 --- gnss/GnssAdapter.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/gnss/GnssAdapter.cpp b/gnss/GnssAdapter.cpp index 2039465..edfc150 100644 --- a/gnss/GnssAdapter.cpp +++ b/gnss/GnssAdapter.cpp @@ -303,11 +303,11 @@ GnssAdapter::convertLocationInfo(GnssLocationInfoNotification& out, } if (GPS_LOCATION_EXTENDED_HAS_NORTH_STD_DEV & locationExtended.flags) { out.flags |= GNSS_LOCATION_INFO_NORTH_STD_DEV_BIT; - out.northVelocityStdDeviation = locationExtended.northStdDeviation; + out.northStdDeviation = locationExtended.northStdDeviation; } if (GPS_LOCATION_EXTENDED_HAS_EAST_STD_DEV & locationExtended.flags) { out.flags |= GNSS_LOCATION_INFO_EAST_STD_DEV_BIT; - out.eastVelocityStdDeviation = locationExtended.eastStdDeviation; + out.eastStdDeviation = locationExtended.eastStdDeviation; } if (GPS_LOCATION_EXTENDED_HAS_NORTH_VEL & locationExtended.flags) { out.flags |= GNSS_LOCATION_INFO_NORTH_VEL_BIT; -- cgit v1.2.3 From 81f47db3f25e00ca7f2571c9211ce47d273d6f97 Mon Sep 17 00:00:00 2001 From: Wei Chen Date: Tue, 30 Apr 2019 15:02:43 -0700 Subject: GPS: add numSVUsedInFix in location api Add a count in location API for number of SV used in fix Change-Id: I3b396170948fa6c93a88d0fdcf17e28eff5ed5dc CRs-fixed: 2425599 --- gnss/GnssAdapter.cpp | 39 ++++++++++++++++++++++++++++++++++++++- gnss/GnssAdapter.h | 2 ++ location/LocationDataTypes.h | 9 +++++++-- 3 files changed, 47 insertions(+), 3 deletions(-) diff --git a/gnss/GnssAdapter.cpp b/gnss/GnssAdapter.cpp index 2039465..a886495 100644 --- a/gnss/GnssAdapter.cpp +++ b/gnss/GnssAdapter.cpp @@ -225,6 +225,31 @@ GnssAdapter::convertLocation(Location& out, const UlpLocation& ulpLocation, } } +/* This is utility routine that computes number of SV used + in the fix from the svUsedIdsMask. + */ +#define MAX_SV_CNT_SUPPORTED_IN_ONE_CONSTELLATION 64 +uint16_t GnssAdapter::getNumSvUsed(uint64_t svUsedIdsMask, + int totalSvCntInThisConstellation) +{ + if (totalSvCntInThisConstellation > MAX_SV_CNT_SUPPORTED_IN_ONE_CONSTELLATION) { + LOC_LOGe ("error: total SV count in this constellation %d exceeded limit of %d", + totalSvCntInThisConstellation, MAX_SV_CNT_SUPPORTED_IN_ONE_CONSTELLATION); + return 0; + } + + uint16_t numSvUsed = 0; + uint64_t mask = 0x1; + for (int i = 0; i < totalSvCntInThisConstellation; i++) { + if (svUsedIdsMask & mask) { + numSvUsed++; + } + mask <<= 1; + } + + return numSvUsed; +} + void GnssAdapter::convertLocationInfo(GnssLocationInfoNotification& out, const GpsLocationExtended& locationExtended) @@ -345,8 +370,20 @@ GnssAdapter::convertLocationInfo(GnssLocationInfoNotification& out, locationExtended.gnss_sv_used_ids.bds_sv_used_ids_mask; out.svUsedInPosition.qzssSvUsedIdsMask = locationExtended.gnss_sv_used_ids.qzss_sv_used_ids_mask; - out.numOfMeasReceived = locationExtended.numOfMeasReceived; + out.flags |= GNSS_LOCATION_INFO_NUM_SV_USED_IN_POSITION_BIT; + out.numSvUsedInPosition = getNumSvUsed(out.svUsedInPosition.gpsSvUsedIdsMask, + GPS_SV_PRN_MAX - GPS_SV_PRN_MIN + 1); + out.numSvUsedInPosition += getNumSvUsed(out.svUsedInPosition.gloSvUsedIdsMask, + GLO_SV_PRN_MAX - GLO_SV_PRN_MIN + 1); + out.numSvUsedInPosition += getNumSvUsed(out.svUsedInPosition.qzssSvUsedIdsMask, + QZSS_SV_PRN_MAX - QZSS_SV_PRN_MIN + 1); + out.numSvUsedInPosition += getNumSvUsed(out.svUsedInPosition.bdsSvUsedIdsMask, + BDS_SV_PRN_MAX - BDS_SV_PRN_MIN + 1); + out.numSvUsedInPosition += getNumSvUsed(out.svUsedInPosition.galSvUsedIdsMask, + GAL_SV_PRN_MAX - GAL_SV_PRN_MIN + 1); + + out.numOfMeasReceived = locationExtended.numOfMeasReceived; for (int idx =0; idx < locationExtended.numOfMeasReceived; idx++) { out.measUsageInfo[idx].gnssSignalType = locationExtended.measUsageInfo[idx].gnssSignalType; diff --git a/gnss/GnssAdapter.h b/gnss/GnssAdapter.h index 9720ba4..eb5a7e4 100644 --- a/gnss/GnssAdapter.h +++ b/gnss/GnssAdapter.h @@ -200,6 +200,8 @@ class GnssAdapter : public LocAdapterBase { const LocPosTechMask techMask); static void convertLocationInfo(GnssLocationInfoNotification& out, const GpsLocationExtended& locationExtended); + static uint16_t getNumSvUsed(uint64_t svUsedIdsMask, + int totalSvCntInThisConstellation); /* ======== UTILITIES ================================================================== */ inline void initOdcpi(const OdcpiRequestCallback& callback); diff --git a/location/LocationDataTypes.h b/location/LocationDataTypes.h index f8bb6cb..0c8e157 100644 --- a/location/LocationDataTypes.h +++ b/location/LocationDataTypes.h @@ -153,7 +153,9 @@ typedef enum { GNSS_LOCATION_INFO_HOR_ACCURACY_ELIP_SEMI_MAJOR_BIT = (1<<5), // valid elipsode semi major GNSS_LOCATION_INFO_HOR_ACCURACY_ELIP_SEMI_MINOR_BIT = (1<<6), // valid elipsode semi minor GNSS_LOCATION_INFO_HOR_ACCURACY_ELIP_AZIMUTH_BIT = (1<<7), // valid accuracy elipsode azimuth - GNSS_LOCATION_INFO_GNSS_SV_USED_DATA_BIT = (1<<8), // valid gnss sv used in pos data + GNSS_LOCATION_INFO_GNSS_SV_USED_DATA_BIT = (1<<8), // valid svUsedInPosition, + // numOfMeasReceived + // and measUsageInfo GNSS_LOCATION_INFO_NAV_SOLUTION_MASK_BIT = (1<<9), // valid navSolutionMask GNSS_LOCATION_INFO_POS_TECH_MASK_BIT = (1<<10),// valid LocPosTechMask GNSS_LOCATION_INFO_SV_SOURCE_INFO_BIT = (1<<11),// valid LocSvInfoSource @@ -168,7 +170,9 @@ typedef enum { GNSS_LOCATION_INFO_EAST_VEL_UNC_BIT = (1<<20),// valid East Velocity Uncertainty GNSS_LOCATION_INFO_UP_VEL_UNC_BIT = (1<<21),// valid Up Velocity Uncertainty GNSS_LOCATION_INFO_LEAP_SECONDS_BIT = (1<<22),// valid leap seconds - GNSS_LOCATION_INFO_TIME_UNC_BIT = (1<<23) // valid time uncertainty + GNSS_LOCATION_INFO_TIME_UNC_BIT = (1<<23),// valid time uncertainty + GNSS_LOCATION_INFO_NUM_SV_USED_IN_POSITION_BIT = (1<<24) // number of SV used in position + } GnssLocationInfoFlagBits; typedef enum { @@ -940,6 +944,7 @@ typedef struct { float northVelocityStdDeviation; float eastVelocityStdDeviation; float upVelocityStdDeviation; + uint16_t numSvUsedInPosition; GnssLocationSvUsedInPosition svUsedInPosition;// Gnss sv used in position data GnssLocationNavSolutionMask navSolutionMask; // Nav solution mask to indicate sbas corrections GnssLocationPosTechMask posTechMask; // Position technology used in computing this fix -- cgit v1.2.3 From 3e62412eb0233619684ecdbc39b19cbc8ebbdc93 Mon Sep 17 00:00:00 2001 From: Wei Chen Date: Fri, 22 Feb 2019 17:55:39 -0800 Subject: Gnss interface: add position injection for extended info Add position injection interface with extended info, e.g.: GnssLocationInfoNotification Change-Id: I6ba8f1111d1511c7071fe358687a478b26e8f9a4 CRs-fixed: 2417450 --- gnss/GnssAdapter.cpp | 27 +++++++++++++++++++++++++++ gnss/GnssAdapter.h | 2 ++ gnss/location_gnss.cpp | 11 ++++++++++- location/location_interface.h | 1 + 4 files changed, 40 insertions(+), 1 deletion(-) diff --git a/gnss/GnssAdapter.cpp b/gnss/GnssAdapter.cpp index edfc150..436681a 100644 --- a/gnss/GnssAdapter.cpp +++ b/gnss/GnssAdapter.cpp @@ -1819,6 +1819,33 @@ GnssAdapter::injectLocationCommand(double latitude, double longitude, float accu latitude, longitude, accuracy)); } +void +GnssAdapter::injectLocationExtCommand(const GnssLocationInfoNotification &locationInfo) +{ + LOC_LOGd("latitude %8.4f longitude %8.4f accuracy %8.4f, tech mask 0x%x", + locationInfo.location.latitude, locationInfo.location.longitude, + locationInfo.location.accuracy, locationInfo.location.techMask); + + struct MsgInjectLocationExt : public LocMsg { + LocApiBase& mApi; + ContextBase& mContext; + GnssLocationInfoNotification mLocationInfo; + inline MsgInjectLocationExt(LocApiBase& api, + ContextBase& context, + GnssLocationInfoNotification locationInfo) : + LocMsg(), + mApi(api), + mContext(context), + mLocationInfo(locationInfo) {} + inline virtual void proc() const { + // false to indicate for none-ODCPI + mApi.injectPosition(mLocationInfo, false); + } + }; + + sendMsg(new MsgInjectLocationExt(*mLocApi, *mContext, locationInfo)); +} + void GnssAdapter::injectTimeCommand(int64_t time, int64_t timeReference, int32_t uncertainty) { diff --git a/gnss/GnssAdapter.h b/gnss/GnssAdapter.h index 9720ba4..ae5f5f1 100644 --- a/gnss/GnssAdapter.h +++ b/gnss/GnssAdapter.h @@ -430,6 +430,8 @@ public: GnssSvId initialSvId, GnssSvType svType); void injectLocationCommand(double latitude, double longitude, float accuracy); + void injectLocationExtCommand(const GnssLocationInfoNotification &locationInfo); + void injectTimeCommand(int64_t time, int64_t timeReference, int32_t uncertainty); void blockCPICommand(double latitude, double longitude, float accuracy, int blockDurationMsec, double latLonDiffThreshold); diff --git a/gnss/location_gnss.cpp b/gnss/location_gnss.cpp index 43665b4..88fa15d 100644 --- a/gnss/location_gnss.cpp +++ b/gnss/location_gnss.cpp @@ -58,6 +58,7 @@ static void gnssGetSvTypeConfig(GnssSvTypeConfigCallback& callback); static void gnssResetSvTypeConfig(); static void injectLocation(double latitude, double longitude, float accuracy); +static void injectLocationExt(const GnssLocationInfoNotification &locationInfo); static void injectTime(int64_t time, int64_t timeReference, int32_t uncertainty); static void agpsInit(const AgpsCbInfo& cbInfo); @@ -113,7 +114,8 @@ static const GnssInterface gGnssInterface = { getGnssEnergyConsumed, enableNfwLocationAccess, nfwInit, - getPowerStateChanges + getPowerStateChanges, + injectLocationExt }; #ifndef DEBUG_X86 @@ -373,3 +375,10 @@ static void getPowerStateChanges(void* powerStateCb) gGnssAdapter->getPowerStateChangesCommand(powerStateCb); } } + +static void injectLocationExt(const GnssLocationInfoNotification &locationInfo) +{ + if (NULL != gGnssAdapter) { + gGnssAdapter->injectLocationExtCommand(locationInfo); + } +} diff --git a/location/location_interface.h b/location/location_interface.h index 4235a13..80f37c2 100644 --- a/location/location_interface.h +++ b/location/location_interface.h @@ -86,6 +86,7 @@ struct GnssInterface { void (*enableNfwLocationAccess)(bool enable); void (*nfwInit)(const NfwCbInfo& cbInfo); void (*getPowerStateChanges)(void* powerStateCb); + void (*injectLocationExt)(const GnssLocationInfoNotification &locationInfo); }; struct BatchingInterface { -- cgit v1.2.3 From 8890e5aeeeb972ea937d8a84f0e8507120a956b9 Mon Sep 17 00:00:00 2001 From: Mike Cailean Date: Tue, 30 Apr 2019 14:44:12 -0700 Subject: When sending GPS LOCK status to XTRA mask NFW bit Change-Id: Icdc26358627abf4097dcb8dc4fb35af039fd921d CRs-fixed: 2444862 --- gnss/XtraSystemStatusObserver.cpp | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/gnss/XtraSystemStatusObserver.cpp b/gnss/XtraSystemStatusObserver.cpp index 6e1902c..b1c48d7 100644 --- a/gnss/XtraSystemStatusObserver.cpp +++ b/gnss/XtraSystemStatusObserver.cpp @@ -57,7 +57,9 @@ using namespace loc_core; #define LOG_TAG "LocSvc_XSSO" bool XtraSystemStatusObserver::updateLockStatus(GnssConfigGpsLock lock) { - mGpsLock = lock; + // mask NI(NFW bit) since from XTRA's standpoint GPS is enabled if + // MO(AFW bit) is enabled and disabled when MO is disabled + mGpsLock = lock & ~GNSS_CONFIG_GPS_LOCK_NI; if (!mReqStatusReceived) { return true; -- cgit v1.2.3 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 +- gnss/GnssAdapter.cpp | 7 +- 16 files changed, 785 insertions(+), 227 deletions(-) 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; } diff --git a/gnss/GnssAdapter.cpp b/gnss/GnssAdapter.cpp index edfc150..5253a1b 100644 --- a/gnss/GnssAdapter.cpp +++ b/gnss/GnssAdapter.cpp @@ -1954,9 +1954,6 @@ GnssAdapter::updateClientsEventMask() if (it->second.trackingCb != nullptr || it->second.gnssLocationInfoCb != nullptr) { mask |= LOC_API_ADAPTER_BIT_PARSED_POSITION_REPORT; } - if (it->second.gnssNiCb != nullptr) { - mask |= LOC_API_ADAPTER_BIT_NI_NOTIFY_VERIFY_REQUEST; - } if (it->second.gnssSvCb != nullptr) { mask |= LOC_API_ADAPTER_BIT_SATELLITE_REPORT; } @@ -2005,6 +2002,10 @@ GnssAdapter::updateClientsEventMask() // need to register for leap second info // for proper nmea generation mask |= LOC_API_ADAPTER_BIT_LOC_SYSTEM_INFO; + + // always register for NI NOTIFY VERIFY to handle internally in HAL + mask |= LOC_API_ADAPTER_BIT_NI_NOTIFY_VERIFY_REQUEST; + updateEvtMask(mask, LOC_REGISTRATION_MASK_SET); } -- cgit v1.2.3 From 2c71ec9e02ea234106d520717fc36eb4f3ad7c48 Mon Sep 17 00:00:00 2001 From: Katz Yamada Date: Fri, 11 May 2018 14:59:44 -0700 Subject: feat: Add timeuncNs in PQWM1 message Add timeuncNs field in PQWM1 of debug NMEA message generated by modem. SystemStaus to parse it. GnssDebug adds this value in timeunc when it generates GNSS debug report. Change-Id: I649915f95730dc8db22e8b4cb88008edc6d8b9d0 CRs-Fixed: 2236950 --- android/1.1/GnssDebug.cpp | 10 ++++++---- android/2.0/GnssDebug.cpp | 18 +++++++++++------- core/SystemStatus.cpp | 19 ++++++++++++++----- core/SystemStatus.h | 4 +++- gnss/GnssAdapter.cpp | 15 ++++++++++++--- 5 files changed, 46 insertions(+), 20 deletions(-) diff --git a/android/1.1/GnssDebug.cpp b/android/1.1/GnssDebug.cpp index ce39476..f164c54 100644 --- a/android/1.1/GnssDebug.cpp +++ b/android/1.1/GnssDebug.cpp @@ -36,7 +36,8 @@ using ::android::hardware::hidl_vec; #define GNSS_DEBUG_UNKNOWN_BEARING_ACCURACY_DEG (180) #define GNSS_DEBUG_UNKNOWN_UTC_TIME (1483228800000LL) // 1/1/2017 00:00 GMT -#define GNSS_DEBUG_UNKNOWN_UTC_TIME_UNC (1.57783680E17) // 5 years in ns +#define GNSS_DEBUG_UNKNOWN_UTC_TIME_UNC_MIN (999) // 999 ns +#define GNSS_DEBUG_UNKNOWN_UTC_TIME_UNC_MAX (1.57783680E17) // 5 years in ns #define GNSS_DEBUG_UNKNOWN_FREQ_UNC_NS_PER_SEC (2.0e5) // ppm GnssDebug::GnssDebug(Gnss* gnss) : mGnss(gnss) @@ -125,9 +126,10 @@ Return GnssDebug::getDebugData(getDebugData_cb _hidl_cb) 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.timeUncertaintyNs <= 0) { + data.time.timeUncertaintyNs = (float)GNSS_DEBUG_UNKNOWN_UTC_TIME_UNC_MIN; + } else if (data.time.timeUncertaintyNs > GNSS_DEBUG_UNKNOWN_UTC_TIME_UNC_MAX) { + data.time.timeUncertaintyNs = (float)GNSS_DEBUG_UNKNOWN_UTC_TIME_UNC_MAX; } if (data.time.frequencyUncertaintyNsPerSec <= 0 || data.time.frequencyUncertaintyNsPerSec > (float)GNSS_DEBUG_UNKNOWN_FREQ_UNC_NS_PER_SEC) { diff --git a/android/2.0/GnssDebug.cpp b/android/2.0/GnssDebug.cpp index b6b9bfe..dc0d9f4 100644 --- a/android/2.0/GnssDebug.cpp +++ b/android/2.0/GnssDebug.cpp @@ -41,7 +41,8 @@ using ::android::hardware::gnss::V2_0::IGnssDebug; #define GNSS_DEBUG_UNKNOWN_BEARING_ACCURACY_DEG (180) #define GNSS_DEBUG_UNKNOWN_UTC_TIME (1483228800000LL) // 1/1/2017 00:00 GMT -#define GNSS_DEBUG_UNKNOWN_UTC_TIME_UNC (1.57783680E17) // 5 years in ns +#define GNSS_DEBUG_UNKNOWN_UTC_TIME_UNC_MIN (999) // 999 ns +#define GNSS_DEBUG_UNKNOWN_UTC_TIME_UNC_MAX (1.57783680E17) // 5 years in ns #define GNSS_DEBUG_UNKNOWN_FREQ_UNC_NS_PER_SEC (2.0e5) // ppm GnssDebug::GnssDebug(Gnss* gnss) : mGnss(gnss) @@ -130,9 +131,10 @@ Return GnssDebug::getDebugData(getDebugData_cb _hidl_cb) 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.timeUncertaintyNs <= 0) { + data.time.timeUncertaintyNs = (float)GNSS_DEBUG_UNKNOWN_UTC_TIME_UNC_MIN; + } else if (data.time.timeUncertaintyNs > GNSS_DEBUG_UNKNOWN_UTC_TIME_UNC_MAX) { + data.time.timeUncertaintyNs = (float)GNSS_DEBUG_UNKNOWN_UTC_TIME_UNC_MAX; } if (data.time.frequencyUncertaintyNsPerSec <= 0 || data.time.frequencyUncertaintyNsPerSec > (float)GNSS_DEBUG_UNKNOWN_FREQ_UNC_NS_PER_SEC) { @@ -247,9 +249,11 @@ Return GnssDebug::getDebugData_2_0(getDebugData_2_0_cb _hidl_cb) 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.timeUncertaintyNs <= 0) { + data.time.timeUncertaintyNs = (float)GNSS_DEBUG_UNKNOWN_UTC_TIME_UNC_MIN; + } + else if (data.time.timeUncertaintyNs > GNSS_DEBUG_UNKNOWN_UTC_TIME_UNC_MAX) { + data.time.timeUncertaintyNs = (float)GNSS_DEBUG_UNKNOWN_UTC_TIME_UNC_MAX; } if (data.time.frequencyUncertaintyNsPerSec <= 0 || data.time.frequencyUncertaintyNsPerSec > (float)GNSS_DEBUG_UNKNOWN_FREQ_UNC_NS_PER_SEC) { diff --git a/core/SystemStatus.cpp b/core/SystemStatus.cpp index 6ef4993..524963b 100644 --- a/core/SystemStatus.cpp +++ b/core/SystemStatus.cpp @@ -126,6 +126,7 @@ public: uint32_t mBdsBpAmpQ; // x1C uint32_t mGalBpAmpI; // x1D uint32_t mGalBpAmpQ; // x1E + uint64_t mTimeUncNs; // x1F }; // parser @@ -157,7 +158,6 @@ private: eAgcGlo = 20, eAgcBds = 21, eAgcGal = 22, - eMax0 = eAgcGal, eLeapSeconds = 23, eLeapSecUnc = 24, eGloBpAmpI = 25, @@ -166,6 +166,8 @@ private: eBdsBpAmpQ = 28, eGalBpAmpI = 29, eGalBpAmpQ = 30, + eMax0 = eGalBpAmpQ, + eTimeUncNs = 31, eMax }; SystemStatusPQWM1 mM1; @@ -201,6 +203,7 @@ public: inline uint32_t getBdsBpAmpQ() { return mM1.mBdsBpAmpQ; } inline uint32_t getGalBpAmpI() { return mM1.mGalBpAmpI; } inline uint32_t getGalBpAmpQ() { return mM1.mGalBpAmpQ; } + inline uint64_t getTimeUncNs() { return mM1.mTimeUncNs; } SystemStatusPQWM1parser(const char *str_in, uint32_t len_in) : SystemStatusNmeaBase(str_in, len_in) @@ -245,6 +248,9 @@ public: mM1.mGalBpAmpI = atoi(mField[eGalBpAmpI].c_str()); mM1.mGalBpAmpQ = atoi(mField[eGalBpAmpQ].c_str()); } + if (mField.size() > eTimeUncNs) { + mM1.mTimeUncNs = strtoull(mField[eTimeUncNs].c_str(), nullptr, 10); + } } inline SystemStatusPQWM1& get() { return mM1;} //getparser @@ -715,7 +721,8 @@ SystemStatusTimeAndClock::SystemStatusTimeAndClock(const SystemStatusPQWM1& nmea mClockFreqBias(nmea.mClockFreqBias), mClockFreqBiasUnc(nmea.mClockFreqBiasUnc), mLeapSeconds(nmea.mLeapSeconds), - mLeapSecUnc(nmea.mLeapSecUnc) + mLeapSecUnc(nmea.mLeapSecUnc), + mTimeUncNs(nmea.mTimeUncNs) { } @@ -729,7 +736,8 @@ bool SystemStatusTimeAndClock::equals(const SystemStatusTimeAndClock& peer) (mClockFreqBias != peer.mClockFreqBias) || (mClockFreqBiasUnc != peer.mClockFreqBiasUnc) || (mLeapSeconds != peer.mLeapSeconds) || - (mLeapSecUnc != peer.mLeapSecUnc)) { + (mLeapSecUnc != peer.mLeapSecUnc) || + (mTimeUncNs != peer.mTimeUncNs)) { return false; } return true; @@ -737,7 +745,7 @@ bool SystemStatusTimeAndClock::equals(const SystemStatusTimeAndClock& peer) void SystemStatusTimeAndClock::dump() { - LOC_LOGV("TimeAndClock: u=%ld:%ld g=%d:%d v=%d ts=%d tu=%d b=%d bu=%d ls=%d lu=%d", + LOC_LOGV("TimeAndClock: u=%ld:%ld g=%d:%d v=%d ts=%d tu=%d b=%d bu=%d ls=%d lu=%d un=%" PRIu64, mUtcTime.tv_sec, mUtcTime.tv_nsec, mGpsWeek, mGpsTowMs, @@ -747,7 +755,8 @@ void SystemStatusTimeAndClock::dump() mClockFreqBias, mClockFreqBiasUnc, mLeapSeconds, - mLeapSecUnc); + mLeapSecUnc, + mTimeUncNs); return; } diff --git a/core/SystemStatus.h b/core/SystemStatus.h index 73a220a..399a6c4 100644 --- a/core/SystemStatus.h +++ b/core/SystemStatus.h @@ -116,6 +116,7 @@ public: int32_t mClockFreqBiasUnc; int32_t mLeapSeconds; int32_t mLeapSecUnc; + uint64_t mTimeUncNs; inline SystemStatusTimeAndClock() : mGpsWeek(0), mGpsTowMs(0), @@ -125,7 +126,8 @@ public: mClockFreqBias(0), mClockFreqBiasUnc(0), mLeapSeconds(0), - mLeapSecUnc(0) {} + mLeapSecUnc(0), + mTimeUncNs(0ULL) {} inline SystemStatusTimeAndClock(const SystemStatusPQWM1& nmea); bool equals(const SystemStatusTimeAndClock& peer); void dump(void); diff --git a/gnss/GnssAdapter.cpp b/gnss/GnssAdapter.cpp index 5253a1b..1a6bdd9 100644 --- a/gnss/GnssAdapter.cpp +++ b/gnss/GnssAdapter.cpp @@ -4340,9 +4340,18 @@ bool GnssAdapter::getDebugReport(GnssDebugReport& r) (int64_t)(reports.mTimeAndClock.back().mLeapSeconds))*1000ULL + (int64_t)(reports.mTimeAndClock.back().mGpsTowMs); - r.mTime.timeUncertaintyNs = - ((float)(reports.mTimeAndClock.back().mTimeUnc) + - (float)(reports.mTimeAndClock.back().mLeapSecUnc))*1000.0f; + if (reports.mTimeAndClock.back().mTimeUncNs > 0) { + // TimeUncNs value is available + r.mTime.timeUncertaintyNs = + (float)(reports.mTimeAndClock.back().mLeapSecUnc)*1000.0f + + (float)(reports.mTimeAndClock.back().mTimeUncNs); + } else { + // fall back to legacy TimeUnc + r.mTime.timeUncertaintyNs = + ((float)(reports.mTimeAndClock.back().mTimeUnc) + + (float)(reports.mTimeAndClock.back().mLeapSecUnc))*1000.0f; + } + r.mTime.frequencyUncertaintyNsPerSec = (float)(reports.mTimeAndClock.back().mClockFreqBiasUnc); LOC_LOGV("getDebugReport - timeestimate=%" PRIu64 " unc=%f frequnc=%f", -- cgit v1.2.3 From bb5cbeed24bdf26ff6dc54592bbaca6e1f418865 Mon Sep 17 00:00:00 2001 From: Mike Cailean Date: Thu, 25 Apr 2019 16:08:26 -0700 Subject: Age Second field in GNSS debug data is incorrect Change-Id: Iec28f9dbbc3b9cfe9a5d06e1f198a02cf09047be CRs-fixed: 2434780 --- core/SystemStatus.h | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/core/SystemStatus.h b/core/SystemStatus.h index 399a6c4..0dbcf91 100644 --- a/core/SystemStatus.h +++ b/core/SystemStatus.h @@ -68,15 +68,15 @@ namespace loc_core class SystemStatusItemBase { public: - timespec mUtcTime; // UTC timestamp when this info was last updated - timespec mUtcReported; // UTC timestamp when this info was reported + timespec mUtcTime; + timespec mUtcReported; static const uint32_t maxItem = 5; SystemStatusItemBase() { - struct timespec tv; - clock_gettime(CLOCK_MONOTONIC, &tv); + timeval tv; + gettimeofday(&tv, NULL); mUtcTime.tv_sec = tv.tv_sec; - mUtcTime.tv_nsec = tv.tv_nsec; + mUtcTime.tv_nsec = tv.tv_usec*1000ULL; mUtcReported = mUtcTime; }; virtual ~SystemStatusItemBase() {}; -- cgit v1.2.3 From 76e761da5a0ebc4ae8d888416e1f8db27cc5f9e7 Mon Sep 17 00:00:00 2001 From: Mike Cailean Date: Sun, 28 Apr 2019 08:16:57 -0700 Subject: SV "in-use" flags are not being set correctly for multiband enabled devices Change-Id: I875b535063c6aa6ecb713c7b6abff123d8402d62 CRs-fixed: 2443087 --- gnss/GnssAdapter.cpp | 99 +++++++++++++++++++++++++++++++++++++++++++++++--- gnss/GnssAdapter.h | 3 ++ utils/gps_extended_c.h | 25 +++++++++++++ 3 files changed, 121 insertions(+), 6 deletions(-) diff --git a/gnss/GnssAdapter.cpp b/gnss/GnssAdapter.cpp index e1143fd..fb5c54f 100644 --- a/gnss/GnssAdapter.cpp +++ b/gnss/GnssAdapter.cpp @@ -95,7 +95,10 @@ GnssAdapter::GnssAdapter() : mAllowFlpNetworkFixes(0), mGnssEnergyConsumedCb(nullptr), mPowerStateCb(nullptr), - mIsE911Session(NULL) + mIsE911Session(NULL), + mGnssMbSvIdUsedInPosition{}, + mGnssMbSvIdUsedInPosAvail(false), + mGnssSignalType() { LOC_LOGD("%s]: Constructor %p", __func__, this); mLocPositionMode.mode = LOC_POSITION_MODE_INVALID; @@ -3136,10 +3139,18 @@ GnssAdapter::reportPosition(const UlpLocation& ulpLocation, } mGnssSvIdUsedInPosAvail = false; + mGnssMbSvIdUsedInPosAvail = false; if (reportToGnssClient) { if (locationExtended.flags & GPS_LOCATION_EXTENDED_HAS_GNSS_SV_USED_DATA) { mGnssSvIdUsedInPosAvail = true; mGnssSvIdUsedInPosition = locationExtended.gnss_sv_used_ids; + if (locationExtended.flags & GPS_LOCATION_EXTENDED_HAS_MULTIBAND) { + mGnssMbSvIdUsedInPosAvail = true; + mGnssMbSvIdUsedInPosition = locationExtended.gnss_mb_sv_used_ids; + for (int i = 0; i < GNSS_SV_MAX; i++) { + mGnssSignalType[i] = locationExtended.measUsageInfo[i].gnssSignalType; + } + } } // if engine hub is running and the fix is from sensor, e.g.: DRE, @@ -3210,27 +3221,103 @@ GnssAdapter::reportSv(GnssSvNotification& svNotify) switch (svNotify.gnssSvs[i].type) { case GNSS_SV_TYPE_GPS: if (mGnssSvIdUsedInPosAvail) { - svUsedIdMask = mGnssSvIdUsedInPosition.gps_sv_used_ids_mask; + if (mGnssMbSvIdUsedInPosAvail) { + switch (mGnssSignalType[i]) { + case GNSS_SIGNAL_GPS_L1CA: + svUsedIdMask = mGnssMbSvIdUsedInPosition.gps_l1ca_sv_used_ids_mask; + break; + case GNSS_SIGNAL_GPS_L1C: + svUsedIdMask = mGnssMbSvIdUsedInPosition.gps_l1c_sv_used_ids_mask; + break; + case GNSS_SIGNAL_GPS_L2: + svUsedIdMask = mGnssMbSvIdUsedInPosition.gps_l2_sv_used_ids_mask; + break; + case GNSS_SIGNAL_GPS_L5: + svUsedIdMask = mGnssMbSvIdUsedInPosition.gps_l5_sv_used_ids_mask; + break; + } + } else { + svUsedIdMask = mGnssSvIdUsedInPosition.gps_sv_used_ids_mask; + } } break; case GNSS_SV_TYPE_GLONASS: if (mGnssSvIdUsedInPosAvail) { - svUsedIdMask = mGnssSvIdUsedInPosition.glo_sv_used_ids_mask; + if (mGnssMbSvIdUsedInPosAvail) { + switch (mGnssSignalType[i]) { + case GNSS_SIGNAL_GLONASS_G1: + svUsedIdMask = mGnssMbSvIdUsedInPosition.glo_g1_sv_used_ids_mask; + break; + case GNSS_SIGNAL_GLONASS_G2: + svUsedIdMask = mGnssMbSvIdUsedInPosition.glo_g2_sv_used_ids_mask; + break; + } + } else { + svUsedIdMask = mGnssSvIdUsedInPosition.glo_sv_used_ids_mask; + } } break; case GNSS_SV_TYPE_BEIDOU: if (mGnssSvIdUsedInPosAvail) { - svUsedIdMask = mGnssSvIdUsedInPosition.bds_sv_used_ids_mask; + if (mGnssMbSvIdUsedInPosAvail) { + switch (mGnssSignalType[i]) { + case GNSS_SIGNAL_BEIDOU_B1I: + svUsedIdMask = mGnssMbSvIdUsedInPosition.bds_b1i_sv_used_ids_mask; + break; + case GNSS_SIGNAL_BEIDOU_B1C: + svUsedIdMask = mGnssMbSvIdUsedInPosition.bds_b1c_sv_used_ids_mask; + break; + case GNSS_SIGNAL_BEIDOU_B2I: + svUsedIdMask = mGnssMbSvIdUsedInPosition.bds_b2i_sv_used_ids_mask; + break; + case GNSS_SIGNAL_BEIDOU_B2AI: + svUsedIdMask = mGnssMbSvIdUsedInPosition.bds_b2ai_sv_used_ids_mask; + break; + } + } else { + svUsedIdMask = mGnssSvIdUsedInPosition.bds_sv_used_ids_mask; + } } break; case GNSS_SV_TYPE_GALILEO: if (mGnssSvIdUsedInPosAvail) { - svUsedIdMask = mGnssSvIdUsedInPosition.gal_sv_used_ids_mask; + if (mGnssMbSvIdUsedInPosAvail) { + switch (mGnssSignalType[i]) { + case GNSS_SIGNAL_GALILEO_E1: + svUsedIdMask = mGnssMbSvIdUsedInPosition.gal_e1_sv_used_ids_mask; + break; + case GNSS_SIGNAL_GALILEO_E5A: + svUsedIdMask = mGnssMbSvIdUsedInPosition.gal_e5a_sv_used_ids_mask; + break; + case GNSS_SIGNAL_GALILEO_E5B: + svUsedIdMask = mGnssMbSvIdUsedInPosition.gal_e5b_sv_used_ids_mask; + break; + } + } else { + svUsedIdMask = mGnssSvIdUsedInPosition.gal_sv_used_ids_mask; + } } break; case GNSS_SV_TYPE_QZSS: if (mGnssSvIdUsedInPosAvail) { - svUsedIdMask = mGnssSvIdUsedInPosition.qzss_sv_used_ids_mask; + if (mGnssMbSvIdUsedInPosAvail) { + switch (mGnssSignalType[i]) { + case GNSS_SIGNAL_QZSS_L1CA: + svUsedIdMask = mGnssMbSvIdUsedInPosition.qzss_l1ca_sv_used_ids_mask; + break; + case GNSS_SIGNAL_QZSS_L1S: + svUsedIdMask = mGnssMbSvIdUsedInPosition.qzss_l1s_sv_used_ids_mask; + break; + case GNSS_SIGNAL_QZSS_L2: + svUsedIdMask = mGnssMbSvIdUsedInPosition.qzss_l2_sv_used_ids_mask; + break; + case GNSS_SIGNAL_QZSS_L5: + svUsedIdMask = mGnssMbSvIdUsedInPosition.qzss_l5_sv_used_ids_mask; + break; + } + } else { + svUsedIdMask = mGnssSvIdUsedInPosition.qzss_sv_used_ids_mask; + } } // QZSS SV id's need to reported as it is to framework, since // framework expects it as it is. See GnssStatus.java. diff --git a/gnss/GnssAdapter.h b/gnss/GnssAdapter.h index 6f652e6..13efab1 100644 --- a/gnss/GnssAdapter.h +++ b/gnss/GnssAdapter.h @@ -145,6 +145,9 @@ class GnssAdapter : public LocAdapterBase { LocPosMode mLocPositionMode; GnssSvUsedInPosition mGnssSvIdUsedInPosition; bool mGnssSvIdUsedInPosAvail; + GnssSvMbUsedInPosition mGnssMbSvIdUsedInPosition; + bool mGnssMbSvIdUsedInPosAvail; + GnssSignalTypeMask mGnssSignalType[GNSS_SV_MAX]; /* ==== CONTROL ======================================================================== */ LocationControlCallbacks mControlCallbacks; diff --git a/utils/gps_extended_c.h b/utils/gps_extended_c.h index 1851783..ba63c5c 100644 --- a/utils/gps_extended_c.h +++ b/utils/gps_extended_c.h @@ -373,6 +373,8 @@ typedef uint64_t GpsLocationExtendedFlags; #define GPS_LOCATION_EXTENDED_HAS_TIME_UNC 0x100000000 /** GpsLocationExtended has heading rate **/ #define GPS_LOCATION_EXTENDED_HAS_HEADING_RATE 0x200000000 +/** GpsLocationExtended has multiband signals **/ +#define GPS_LOCATION_EXTENDED_HAS_MULTIBAND 0x400000000 typedef uint32_t LocNavSolutionMask; /* Bitmask to specify whether SBAS ionospheric correction is used */ @@ -467,6 +469,27 @@ typedef struct { uint64_t qzss_sv_used_ids_mask; } GnssSvUsedInPosition; +typedef struct { + uint64_t gps_l1ca_sv_used_ids_mask; // GPS L1CA + uint64_t gps_l1c_sv_used_ids_mask; // GPS L1C + uint64_t gps_l2_sv_used_ids_mask; // GPS L2 + uint64_t gps_l5_sv_used_ids_mask; // GPS L5 + uint64_t glo_g1_sv_used_ids_mask; // GLO G1 + uint64_t glo_g2_sv_used_ids_mask; // GLO G2 + uint64_t gal_e1_sv_used_ids_mask; // GAL E1 + uint64_t gal_e5a_sv_used_ids_mask; // GAL E5A + uint64_t gal_e5b_sv_used_ids_mask; // GAL E5B + uint64_t bds_b1i_sv_used_ids_mask; // BDS B1I + uint64_t bds_b1c_sv_used_ids_mask; // BDS B1C + uint64_t bds_b2i_sv_used_ids_mask; // BDS B2I + uint64_t bds_b2ai_sv_used_ids_mask; // BDS B2AI + uint64_t qzss_l1ca_sv_used_ids_mask; // QZSS L1CA + uint64_t qzss_l1s_sv_used_ids_mask; // QZSS L1S + uint64_t qzss_l2_sv_used_ids_mask; // QZSS L2 + uint64_t qzss_l5_sv_used_ids_mask; // QZSS L5 + uint64_t sbas_l1_sv_used_ids_mask; // SBAS L1 +} GnssSvMbUsedInPosition; + /* Body Frame parameters */ typedef struct { /** Contains Body frame LocPosDataMask bits. */ @@ -689,6 +712,8 @@ typedef struct { Gnss_ApTimeStampStructType timeStamp; /** Gnss sv used in position data */ GnssSvUsedInPosition gnss_sv_used_ids; + /** Gnss sv used in position data for multiband */ + GnssSvMbUsedInPosition gnss_mb_sv_used_ids; /** Nav solution mask to indicate sbas corrections */ LocNavSolutionMask navSolutionMask; /** Position technology used in computing this fix */ -- cgit v1.2.3 From aa95ca27f8db9f0a47116344ca4d12042acdb63b Mon Sep 17 00:00:00 2001 From: Mike Cailean Date: Wed, 1 May 2019 13:19:19 -0700 Subject: Process CP_MTLR in emergency in different conditions Prcess CP_MTLR based on a new configuration item Change-Id: I9351f574f0b1a4bad2b88f2627ab188ac1522e92 CRs-fixed: 2444954 --- core/ContextBase.cpp | 4 +++- core/ContextBase.h | 1 + etc/gps.conf | 6 ++++++ gnss/GnssAdapter.cpp | 16 ++++++++++------ 4 files changed, 20 insertions(+), 7 deletions(-) diff --git a/core/ContextBase.cpp b/core/ContextBase.cpp index 12e550f..084b6bf 100644 --- a/core/ContextBase.cpp +++ b/core/ContextBase.cpp @@ -79,6 +79,7 @@ const loc_param_s_type ContextBase::mGps_conf_table[] = {"CONSTRAINED_TIME_UNCERTAINTY_ENERGY_BUDGET", &mGps_conf.CONSTRAINED_TIME_UNCERTAINTY_ENERGY_BUDGET, NULL, 'n'}, {"POSITION_ASSISTED_CLOCK_ESTIMATOR_ENABLED", &mGps_conf.POSITION_ASSISTED_CLOCK_ESTIMATOR_ENABLED, NULL, 'n'}, {"PROXY_APP_PACKAGE_NAME", &mGps_conf.PROXY_APP_PACKAGE_NAME, NULL, 's' }, + {"CP_MTLR_ES", &mGps_conf.CP_MTLR_ES, NULL, 'n' }, }; const loc_param_s_type ContextBase::mSap_conf_table[] = @@ -112,7 +113,8 @@ void ContextBase::readConfig() mGps_conf.GPS_LOCK = GNSS_CONFIG_GPS_LOCK_MO_AND_NI; mGps_conf.SUPL_VER = 0x10000; mGps_conf.SUPL_MODE = 0x1; - mGps_conf.SUPL_ES = 1; + mGps_conf.SUPL_ES = 0; + mGps_conf.CP_MTLR_ES = 0; mGps_conf.SUPL_HOST[0] = 0; mGps_conf.SUPL_PORT = 0; mGps_conf.CAPABILITIES = 0x7; diff --git a/core/ContextBase.h b/core/ContextBase.h index 8fc2bd5..ab61a08 100644 --- a/core/ContextBase.h +++ b/core/ContextBase.h @@ -72,6 +72,7 @@ typedef struct loc_gps_cfg_s uint32_t CONSTRAINED_TIME_UNCERTAINTY_ENERGY_BUDGET; uint32_t POSITION_ASSISTED_CLOCK_ESTIMATOR_ENABLED; char PROXY_APP_PACKAGE_NAME[LOC_MAX_PARAM_STRING]; + uint32_t CP_MTLR_ES; } loc_gps_cfg_s_type; /* NOTE: the implementaiton of the parser casts number diff --git a/etc/gps.conf b/etc/gps.conf index 2ec3f69..35a0a7e 100644 --- a/etc/gps.conf +++ b/etc/gps.conf @@ -288,3 +288,9 @@ MODEM_TYPE = 1 # This is a string that is sent to the framework # in nfwNotifyCb callback PROXY_APP_PACKAGE_NAME = com.google.android.carrierlocation + +##################################### +# CP_MTLR_ES +##################################### +# CP MTLR ES, 1=enable, 0=disable +CP_MTLR_ES=0 diff --git a/gnss/GnssAdapter.cpp b/gnss/GnssAdapter.cpp index 31cd886..a6d82bf 100644 --- a/gnss/GnssAdapter.cpp +++ b/gnss/GnssAdapter.cpp @@ -3409,16 +3409,20 @@ GnssAdapter::requestNiNotifyEvent(const GnssNiNotification ¬ify, const void* mNotify(notify), mData(data) {} inline virtual void proc() const { - if (GNSS_NI_TYPE_EMERGENCY_SUPL == mNotify.type || - GNSS_NI_TYPE_CONTROL_PLANE == mNotify.type) { + if (GNSS_NI_TYPE_EMERGENCY_SUPL == mNotify.type) { if (mAdapter.getE911State() || - ((GNSS_CONFIG_SUPL_EMERGENCY_SERVICES_NO == ContextBase::mGps_conf.SUPL_ES) && - (GNSS_NI_TYPE_EMERGENCY_SUPL == mNotify.type))) { + (GNSS_CONFIG_SUPL_EMERGENCY_SERVICES_NO == ContextBase::mGps_conf.SUPL_ES)) { mApi.informNiResponse(GNSS_NI_RESPONSE_ACCEPT, mData); - } - else { + } else { mApi.informNiResponse(GNSS_NI_RESPONSE_DENY, mData); } + } else if (GNSS_NI_TYPE_CONTROL_PLANE == mNotify.type) { + if (mAdapter.getE911State() && + (1 == ContextBase::mGps_conf.CP_MTLR_ES)) { + mApi.informNiResponse(GNSS_NI_RESPONSE_ACCEPT, mData); + } else { + mAdapter.requestNiNotify(mNotify, mData); + } } else { mAdapter.requestNiNotify(mNotify, mData); } -- cgit v1.2.3 From e8c1730e91fe1c743b6798cb78551bea67718617 Mon Sep 17 00:00:00 2001 From: Wei Chen Date: Tue, 16 Apr 2019 13:57:09 -0700 Subject: GPS exteneded: add dir name and file prefix for ext ap client Add directory to be reserved for hal daemon to keep track of location client sitting on external application processor Change-Id: I192fb011c786bab1752f0e604b86041a9f4cdc33 CRs-fixed: 2436612 --- utils/gps_extended_c.h | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/utils/gps_extended_c.h b/utils/gps_extended_c.h index ba63c5c..800af9b 100644 --- a/utils/gps_extended_c.h +++ b/utils/gps_extended_c.h @@ -2165,7 +2165,9 @@ typedef void (*LocAgpsCloseResultCb)(bool isSuccess, AGpsExtType agpsType, void* #define SOCKET_DIR_TO_CLIENT "/dev/socket/loc_client/" #define SOCKET_TO_LOCATION_CLIENT_BASE "/dev/socket/loc_client/toclient" -#define SOCKET_TO_EXTERANL_AP_LOCATION_CLIENT_BASE "/dev/socket/loc_client/extap.toclient" + +#define DIR_FOR_EXT_AP_LOC_CLIENT "/data/vendor/location/extap_locclient/" +#define FILE_FOR_EXT_AP_LOC_CLIENT_BASE "/data/vendor/location/extap_locclient/client" typedef uint64_t NetworkHandle; #define NETWORK_HANDLE_UNKNOWN ~0 -- cgit v1.2.3 From ce5531372403e918b782d5b8d5d6c56de22bd69f Mon Sep 17 00:00:00 2001 From: Vamana Thuniki Date: Mon, 22 Apr 2019 22:45:43 +0530 Subject: Enablement of location modules for lito Change-Id: I24277533400f40d3a57b5176d53958dcd6b31a96 CRs-Fixed: 2443595 --- build/target_specific_features.mk | 1 + 1 file changed, 1 insertion(+) diff --git a/build/target_specific_features.mk b/build/target_specific_features.mk index 83f3cdd..ad7f7e1 100644 --- a/build/target_specific_features.mk +++ b/build/target_specific_features.mk @@ -43,6 +43,7 @@ GNSS_HIDL_2_0_TARGET_LIST += $(MSMSTEPPE) GNSS_HIDL_2_0_TARGET_LIST += $(TRINKET) GNSS_HIDL_2_0_TARGET_LIST += kona GNSS_HIDL_2_0_TARGET_LIST += atoll +GNSS_HIDL_2_0_TARGET_LIST += lito ifneq (,$(filter $(GNSS_HIDL_2_0_TARGET_LIST),$(TARGET_BOARD_PLATFORM))) GNSS_HIDL_VERSION = 2.0 -- cgit v1.2.3 From b884edb7c8eac185fffc76bd5261d7b9dd06410d Mon Sep 17 00:00:00 2001 From: Mike Cailean Date: Thu, 2 May 2019 17:09:25 -0700 Subject: Set yearOfHw to 2019 if Location Privacy feature is supported Change-Id: If5ee31603491c83652082ce295abfcf9c9fec511 CRs-fixed: 2446241 --- android/2.0/location_api/GnssAPIClient.cpp | 4 +++- core/LocAdapterBase.cpp | 3 +++ location/LocationDataTypes.h | 2 ++ utils/gps_extended_c.h | 3 ++- 4 files changed, 10 insertions(+), 2 deletions(-) diff --git a/android/2.0/location_api/GnssAPIClient.cpp b/android/2.0/location_api/GnssAPIClient.cpp index 5610f06..68cf395 100644 --- a/android/2.0/location_api/GnssAPIClient.cpp +++ b/android/2.0/location_api/GnssAPIClient.cpp @@ -368,7 +368,9 @@ void GnssAPIClient::onCapabilitiesCb(LocationCapabilitiesMask capabilitiesMask) data |= IGnssCallback::Capabilities::SATELLITE_BLACKLIST; IGnssCallback::GnssSystemInfo gnssInfo; - if (capabilitiesMask & LOCATION_CAPABILITIES_CONSTELLATION_ENABLEMENT_BIT || + 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) { diff --git a/core/LocAdapterBase.cpp b/core/LocAdapterBase.cpp index 6fad918..5864fa8 100644 --- a/core/LocAdapterBase.cpp +++ b/core/LocAdapterBase.cpp @@ -298,6 +298,9 @@ LocAdapterBase::getCapabilities() if (ContextBase::isFeatureSupported(LOC_SUPPORTED_FEATURE_AGPM_V02)) { mask |= LOCATION_CAPABILITIES_AGPM_BIT; } + if (ContextBase::isFeatureSupported(LOC_SUPPORTED_FEATURE_LOCATION_PRIVACY)) { + mask |= LOCATION_CAPABILITIES_PRIVACY_BIT; + } } else { LOC_LOGE("%s]: attempt to get capabilities before they are known.", __func__); } diff --git a/location/LocationDataTypes.h b/location/LocationDataTypes.h index f8bb6cb..09e243a 100644 --- a/location/LocationDataTypes.h +++ b/location/LocationDataTypes.h @@ -218,6 +218,8 @@ typedef enum { LOCATION_CAPABILITIES_CONSTELLATION_ENABLEMENT_BIT = (1<<10), // support agpm LOCATION_CAPABILITIES_AGPM_BIT = (1<<11), + // support location privacy + LOCATION_CAPABILITIES_PRIVACY_BIT = (1<<12), } LocationCapabilitiesBits; typedef enum { diff --git a/utils/gps_extended_c.h b/utils/gps_extended_c.h index 800af9b..a3dcbd0 100644 --- a/utils/gps_extended_c.h +++ b/utils/gps_extended_c.h @@ -126,7 +126,8 @@ typedef enum { LOC_SUPPORTED_FEATURE_CONSTELLATION_ENABLEMENT_V02, /**< Support constellation enablement */ LOC_SUPPORTED_FEATURE_AGPM_V02, /**< Support AGPM feature */ LOC_SUPPORTED_FEATURE_XTRA_INTEGRITY, /**< Support XTRA integrity */ - LOC_SUPPORTED_FEATURE_FDCL_2 /**< Support FDCL V2 */ + LOC_SUPPORTED_FEATURE_FDCL_2, /**< Support FDCL V2 */ + LOC_SUPPORTED_FEATURE_LOCATION_PRIVACY /**< Support location privacy */ } loc_supported_feature_enum; typedef struct { -- cgit v1.2.3 From 2dab397e35c074a5ada5feba06ced80e574f8e2c Mon Sep 17 00:00:00 2001 From: Wei Chen Date: Mon, 22 Apr 2019 12:00:53 -0700 Subject: Gnss adapter: retrieve pdop, hdop and vdop from extended struct For none-SPE engine, pdop, hdop and vdop are set in the extDop struct. Update code to retrieve it from there. Change-Id: I698e960cd90f3d72210cfd0a885080f1546c0c7d Crs-fixed: 2439750 --- gnss/GnssAdapter.cpp | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/gnss/GnssAdapter.cpp b/gnss/GnssAdapter.cpp index 1c80443..2958d9e 100644 --- a/gnss/GnssAdapter.cpp +++ b/gnss/GnssAdapter.cpp @@ -238,17 +238,19 @@ GnssAdapter::convertLocationInfo(GnssLocationInfoNotification& out, out.flags |= GNSS_LOCATION_INFO_ALTITUDE_MEAN_SEA_LEVEL_BIT; out.altitudeMeanSeaLevel = locationExtended.altitudeMeanSeaLevel; } - if (GPS_LOCATION_EXTENDED_HAS_DOP & locationExtended.flags) { + if (GPS_LOCATION_EXTENDED_HAS_EXT_DOP & locationExtended.flags) { + out.flags |= (GNSS_LOCATION_INFO_DOP_BIT|GNSS_LOCATION_INFO_EXT_DOP_BIT); + out.pdop = locationExtended.extDOP.PDOP; + out.hdop = locationExtended.extDOP.HDOP; + out.vdop = locationExtended.extDOP.VDOP; + out.gdop = locationExtended.extDOP.GDOP; + out.tdop = locationExtended.extDOP.TDOP; + } else if (GPS_LOCATION_EXTENDED_HAS_DOP & locationExtended.flags) { out.flags |= GNSS_LOCATION_INFO_DOP_BIT; out.pdop = locationExtended.pdop; out.hdop = locationExtended.hdop; out.vdop = locationExtended.vdop; } - if (GPS_LOCATION_EXTENDED_HAS_EXT_DOP & locationExtended.flags) { - out.flags |= GNSS_LOCATION_INFO_EXT_DOP_BIT; - out.gdop = locationExtended.extDOP.GDOP; - out.tdop = locationExtended.extDOP.TDOP; - } if (GPS_LOCATION_EXTENDED_HAS_MAG_DEV & locationExtended.flags) { out.flags |= GNSS_LOCATION_INFO_MAGNETIC_DEVIATION_BIT; out.magneticDeviation = locationExtended.magneticDeviation; -- cgit v1.2.3 From 8f9d530d90c377eff7563cd58100166dd095de6b Mon Sep 17 00:00:00 2001 From: Dante Russo Date: Mon, 6 May 2019 17:22:39 -0700 Subject: VINTF Manifest fragment for android.hardware.gnss To replace entry in device specific vendor manifest Change-Id: I330f4ef2658074218b5d2c105decaf6cfd959d3f CRs-fixed: 2444785 --- android/1.0/Android.mk | 1 + .../1.0/android.hardware.gnss@1.0-service-qti.xml | 35 +++++++++++++++++++++ android/1.1/Android.mk | 1 + .../1.1/android.hardware.gnss@1.1-service-qti.xml | 35 +++++++++++++++++++++ android/2.0/Android.mk | 1 + .../2.0/android.hardware.gnss@2.0-service-qti.xml | 36 ++++++++++++++++++++++ 6 files changed, 109 insertions(+) create mode 100644 android/1.0/android.hardware.gnss@1.0-service-qti.xml create mode 100644 android/1.1/android.hardware.gnss@1.1-service-qti.xml create mode 100644 android/2.0/android.hardware.gnss@2.0-service-qti.xml diff --git a/android/1.0/Android.mk b/android/1.0/Android.mk index 122ff8d..5489f86 100644 --- a/android/1.0/Android.mk +++ b/android/1.0/Android.mk @@ -50,6 +50,7 @@ include $(BUILD_SHARED_LIBRARY) include $(CLEAR_VARS) LOCAL_MODULE := android.hardware.gnss@1.0-service-qti +LOCAL_VINTF_FRAGMENTS := android.hardware.gnss@1.0-service-qti.xml LOCAL_VENDOR_MODULE := true LOCAL_MODULE_RELATIVE_PATH := hw LOCAL_INIT_RC := android.hardware.gnss@1.0-service-qti.rc diff --git a/android/1.0/android.hardware.gnss@1.0-service-qti.xml b/android/1.0/android.hardware.gnss@1.0-service-qti.xml new file mode 100644 index 0000000..46bcffb --- /dev/null +++ b/android/1.0/android.hardware.gnss@1.0-service-qti.xml @@ -0,0 +1,35 @@ + + + + android.hardware.gnss + hwbinder + @1.0::IGnss/default + + + diff --git a/android/1.1/Android.mk b/android/1.1/Android.mk index 5c97f40..0beaf20 100644 --- a/android/1.1/Android.mk +++ b/android/1.1/Android.mk @@ -51,6 +51,7 @@ include $(BUILD_SHARED_LIBRARY) include $(CLEAR_VARS) LOCAL_MODULE := android.hardware.gnss@1.1-service-qti +LOCAL_VINTF_FRAGMENTS := android.hardware.gnss@1.1-service-qti.xml LOCAL_VENDOR_MODULE := true LOCAL_MODULE_RELATIVE_PATH := hw LOCAL_INIT_RC := android.hardware.gnss@1.1-service-qti.rc diff --git a/android/1.1/android.hardware.gnss@1.1-service-qti.xml b/android/1.1/android.hardware.gnss@1.1-service-qti.xml new file mode 100644 index 0000000..c9c83fb --- /dev/null +++ b/android/1.1/android.hardware.gnss@1.1-service-qti.xml @@ -0,0 +1,35 @@ + + + + android.hardware.gnss + hwbinder + @1.1::IGnss/default + + + diff --git a/android/2.0/Android.mk b/android/2.0/Android.mk index 2000bb8..c33a792 100644 --- a/android/2.0/Android.mk +++ b/android/2.0/Android.mk @@ -63,6 +63,7 @@ include $(BUILD_SHARED_LIBRARY) include $(CLEAR_VARS) LOCAL_MODULE := android.hardware.gnss@2.0-service-qti +LOCAL_VINTF_FRAGMENTS := android.hardware.gnss@2.0-service-qti.xml LOCAL_VENDOR_MODULE := true LOCAL_MODULE_RELATIVE_PATH := hw LOCAL_INIT_RC := android.hardware.gnss@2.0-service-qti.rc diff --git a/android/2.0/android.hardware.gnss@2.0-service-qti.xml b/android/2.0/android.hardware.gnss@2.0-service-qti.xml new file mode 100644 index 0000000..ff9fb2c --- /dev/null +++ b/android/2.0/android.hardware.gnss@2.0-service-qti.xml @@ -0,0 +1,36 @@ + + + + android.hardware.gnss + hwbinder + @1.1::IGnss/default + @2.0::IGnss/default + + + -- cgit v1.2.3 From 2ba3f04c57196968d815eb6eb226531895a47190 Mon Sep 17 00:00:00 2001 From: Bhavna Sharma Date: Thu, 24 Jan 2019 20:27:39 -0800 Subject: LocIpc redesign LocIpc now doesn't have any impelementation of sockets, but a framework that provides threading for any sockets that can be wrapped into LocIpcSender and LocIpcRever APIs. Also updated XtraSystemStatusObserver to using the new LocIpc and LocIpcLocalSender and LocIpcLocalRecver. Change-Id: I506c77198f9ce1e7d4dfd5e596dc0ac21d928e34 CRs-Fixed: 2443124 --- gnss/XtraSystemStatusObserver.cpp | 106 +++++---- gnss/XtraSystemStatusObserver.h | 29 +-- utils/LocIpc.cpp | 462 +++++++++++++++++++++++++------------- utils/LocIpc.h | 186 ++++++++------- utils/Makefile.am | 2 +- utils/gps_extended_c.h | 9 +- 6 files changed, 502 insertions(+), 292 deletions(-) diff --git a/gnss/XtraSystemStatusObserver.cpp b/gnss/XtraSystemStatusObserver.cpp index b1c48d7..4cb6f5f 100644 --- a/gnss/XtraSystemStatusObserver.cpp +++ b/gnss/XtraSystemStatusObserver.cpp @@ -49,6 +49,7 @@ #include #include +using namespace loc_util; using namespace loc_core; #ifdef LOG_TAG @@ -56,6 +57,61 @@ using namespace loc_core; #endif #define LOG_TAG "LocSvc_XSSO" +class XtraIpcListener : public ILocIpcListener { + IOsObserver* mSystemStatusObsrvr; + const MsgTask* mMsgTask; + XtraSystemStatusObserver& mXSSO; +public: + inline XtraIpcListener(IOsObserver* observer, const MsgTask* msgTask, + XtraSystemStatusObserver& xsso) : + mSystemStatusObsrvr(observer), mMsgTask(msgTask), mXSSO(xsso) {} + virtual void onReceive(const char* data, uint32_t length) override { +#define STRNCMP(str, constStr) strncmp(str, constStr, sizeof(constStr)-1) + if (!STRNCMP(data, "ping")) { + LOC_LOGd("ping received"); +#ifdef USE_GLIB + } else if (!STRNCMP(data, "connectBackhaul")) { + mSystemStatusObsrvr->connectBackhaul(); + } else if (!STRNCMP(data, "disconnectBackhaul")) { + mSystemStatusObsrvr->disconnectBackhaul(); +#endif + } else if (!STRNCMP(data, "requestStatus")) { + int32_t xtraStatusUpdated = 0; + sscanf(data, "%*s %d", &xtraStatusUpdated); + + struct HandleStatusRequestMsg : public LocMsg { + XtraSystemStatusObserver& mXSSO; + int32_t mXtraStatusUpdated; + inline HandleStatusRequestMsg(XtraSystemStatusObserver& xsso, + int32_t xtraStatusUpdated) : + mXSSO(xsso), mXtraStatusUpdated(xtraStatusUpdated) {} + inline void proc() const override { + mXSSO.onStatusRequested(mXtraStatusUpdated); + } + }; + mMsgTask->sendMsg(new HandleStatusRequestMsg(mXSSO, xtraStatusUpdated)); + } else { + LOC_LOGw("unknown event: %s", data); + } + } +}; + +XtraSystemStatusObserver::XtraSystemStatusObserver(IOsObserver* sysStatObs, + const MsgTask* msgTask) : + mSystemStatusObsrvr(sysStatObs), mMsgTask(msgTask), + mGpsLock(-1), mConnections(~0), mXtraThrottle(true), + mReqStatusReceived(false), + mIsConnectivityStatusKnown(false), + mSender(LocIpc::getLocIpcLocalSender(LOC_IPC_XTRA)), + mDelayLocTimer(*mSender) { + subscribe(true); + auto recver = LocIpc::getLocIpcLocalRecver( + make_shared(sysStatObs, msgTask, *this), + LOC_IPC_HAL); + mIpc.startNonBlockingListening(recver); + mDelayLocTimer.start(100 /*.1 sec*/, false); +} + bool XtraSystemStatusObserver::updateLockStatus(GnssConfigGpsLock lock) { // mask NI(NFW bit) since from XTRA's standpoint GPS is enabled if // MO(AFW bit) is enabled and disabled when MO is disabled @@ -68,7 +124,8 @@ bool XtraSystemStatusObserver::updateLockStatus(GnssConfigGpsLock lock) { stringstream ss; ss << "gpslock"; ss << " " << lock; - return ( send(LOC_IPC_XTRA, ss.str()) ); + string s = ss.str(); + return ( LocIpc::send(*mSender, (const uint8_t*)s.data(), s.size()) ); } bool XtraSystemStatusObserver::updateConnections(uint64_t allConnections, @@ -85,8 +142,8 @@ bool XtraSystemStatusObserver::updateConnections(uint64_t allConnections, stringstream ss; ss << "connection" << endl << mConnections << endl << wifiNetworkHandle << endl << mobileNetworkHandle; - - return ( send(LOC_IPC_XTRA, ss.str()) ); + string s = ss.str(); + return ( LocIpc::send(*mSender, (const uint8_t*)s.data(), s.size()) ); } bool XtraSystemStatusObserver::updateTac(const string& tac) { @@ -99,7 +156,8 @@ bool XtraSystemStatusObserver::updateTac(const string& tac) { stringstream ss; ss << "tac"; ss << " " << tac.c_str(); - return ( send(LOC_IPC_XTRA, ss.str()) ); + string s = ss.str(); + return ( LocIpc::send(*mSender, (const uint8_t*)s.data(), s.size()) ); } bool XtraSystemStatusObserver::updateMccMnc(const string& mccmnc) { @@ -112,7 +170,8 @@ bool XtraSystemStatusObserver::updateMccMnc(const string& mccmnc) { stringstream ss; ss << "mncmcc"; ss << " " << mccmnc.c_str(); - return ( send(LOC_IPC_XTRA, ss.str()) ); + string s = ss.str(); + return ( LocIpc::send(*mSender, (const uint8_t*)s.data(), s.size()) ); } bool XtraSystemStatusObserver::updateXtraThrottle(const bool enabled) { @@ -125,7 +184,8 @@ bool XtraSystemStatusObserver::updateXtraThrottle(const bool enabled) { stringstream ss; ss << "xtrathrottle"; ss << " " << (enabled ? 1 : 0); - return ( send(LOC_IPC_XTRA, ss.str()) ); + string s = ss.str(); + return ( LocIpc::send(*mSender, (const uint8_t*)s.data(), s.size()) ); } inline bool XtraSystemStatusObserver::onStatusRequested(int32_t xtraStatusUpdated) { @@ -143,38 +203,8 @@ inline bool XtraSystemStatusObserver::onStatusRequested(int32_t xtraStatusUpdate << mWifiNetworkHandle << endl << mMobileNetworkHandle << endl << mTac << endl << mMccmnc << endl << mIsConnectivityStatusKnown; - return ( send(LOC_IPC_XTRA, ss.str()) ); -} - -void XtraSystemStatusObserver::onReceive(const std::string& data) { - if (!strncmp(data.c_str(), "ping", sizeof("ping") - 1)) { - LOC_LOGd("ping received"); - -#ifdef USE_GLIB - } else if (!strncmp(data.c_str(), "connectBackhaul", sizeof("connectBackhaul") - 1)) { - mSystemStatusObsrvr->connectBackhaul(); - - } else if (!strncmp(data.c_str(), "disconnectBackhaul", sizeof("disconnectBackhaul") - 1)) { - mSystemStatusObsrvr->disconnectBackhaul(); -#endif - - } else if (!strncmp(data.c_str(), "requestStatus", sizeof("requestStatus") - 1)) { - int32_t xtraStatusUpdated = 0; - sscanf(data.c_str(), "%*s %d", &xtraStatusUpdated); - - struct HandleStatusRequestMsg : public LocMsg { - XtraSystemStatusObserver& mXSSO; - int32_t mXtraStatusUpdated; - inline HandleStatusRequestMsg(XtraSystemStatusObserver& xsso, - int32_t xtraStatusUpdated) : - mXSSO(xsso), mXtraStatusUpdated(xtraStatusUpdated) {} - inline void proc() const override { mXSSO.onStatusRequested(mXtraStatusUpdated); } - }; - mMsgTask->sendMsg(new (nothrow) HandleStatusRequestMsg(*this, xtraStatusUpdated)); - - } else { - LOC_LOGw("unknown event: %s", data.c_str()); - } + string s = ss.str(); + return ( LocIpc::send(*mSender, (const uint8_t*)s.data(), s.size()) ); } void XtraSystemStatusObserver::subscribe(bool yes) diff --git a/gnss/XtraSystemStatusObserver.h b/gnss/XtraSystemStatusObserver.h index b93ecf2..14f9393 100644 --- a/gnss/XtraSystemStatusObserver.h +++ b/gnss/XtraSystemStatusObserver.h @@ -35,25 +35,18 @@ #include using namespace std; +using namespace loc_util; using loc_core::IOsObserver; using loc_core::IDataItemObserver; using loc_core::IDataItemCore; -using loc_util::LocIpc; -class XtraSystemStatusObserver : public IDataItemObserver, public LocIpc{ +class XtraSystemStatusObserver : public IDataItemObserver { public : // constructor & destructor - inline XtraSystemStatusObserver(IOsObserver* sysStatObs, const MsgTask* msgTask): - mSystemStatusObsrvr(sysStatObs), mMsgTask(msgTask), - mGpsLock(-1), mConnections(~0), mXtraThrottle(true), mReqStatusReceived(false), - mIsConnectivityStatusKnown (false), mDelayLocTimer(*this) { - subscribe(true); - startListeningNonBlocking(LOC_IPC_HAL); - mDelayLocTimer.start(100 /*.1 sec*/, false); - } + XtraSystemStatusObserver(IOsObserver* sysStatObs, const MsgTask* msgTask); inline virtual ~XtraSystemStatusObserver() { subscribe(false); - stopListening(); + mIpc.stopNonBlockingListening(); } // IDataItemObserver overrides @@ -68,14 +61,13 @@ public : bool updateXtraThrottle(const bool enabled); inline const MsgTask* getMsgTask() { return mMsgTask; } void subscribe(bool yes); - -protected: - void onReceive(const std::string& data) override; + bool onStatusRequested(int32_t xtraStatusUpdated); private: IOsObserver* mSystemStatusObsrvr; const MsgTask* mMsgTask; GnssConfigGpsLock mGpsLock; + LocIpc mIpc; uint64_t mConnections; uint64_t mWifiNetworkHandle; uint64_t mMobileNetworkHandle; @@ -84,17 +76,16 @@ private: bool mXtraThrottle; bool mReqStatusReceived; bool mIsConnectivityStatusKnown; + shared_ptr mSender; class DelayLocTimer : public LocTimer { - XtraSystemStatusObserver& mXSSO; + LocIpcSender& mSender; public: - DelayLocTimer(XtraSystemStatusObserver& xsso) : mXSSO(xsso) {} + DelayLocTimer(LocIpcSender& sender) : mSender(sender) {} void timeOutCallback() override { - mXSSO.send(LOC_IPC_XTRA, "halinit"); + LocIpc::send(mSender, (const uint8_t*)"halinit", sizeof("halinit")); } } mDelayLocTimer; - - bool onStatusRequested(int32_t xtraStatusUpdated); }; #endif diff --git a/utils/LocIpc.cpp b/utils/LocIpc.cpp index 4178d52..ecaff01 100644 --- a/utils/LocIpc.cpp +++ b/utils/LocIpc.cpp @@ -30,10 +30,14 @@ #include #include #include +#include +#include +#include #include -#include "LocIpc.h" +#include +#include -using std::string; +using namespace std; namespace loc_util { @@ -42,188 +46,346 @@ namespace loc_util { #endif #define LOG_TAG "LocSvc_LocIpc" -#define LOC_MSG_BUF_LEN 8192 -#define LOC_MSG_HEAD "$MSGLEN$" -#define LOC_MSG_ABORT "LocIpcMsg::ABORT" +#define SOCK_OP_AND_LOG(buf, length, opable, rtv, exe) \ + if (nullptr == (buf) || 0 == (length)) { \ + LOC_LOGe("Invalid inputs: buf - %p, length - %d", (buf), (length)); \ + } else if (!(opable)) { \ + LOC_LOGe("Invalid object: operable - %d", (opable)); \ + } else { \ + rtv = (exe); \ + if (-1 == rtv) { \ + LOC_LOGw("failed reason: %s", strerror(errno)); \ + } \ + } -class LocIpcRunnable : public LocRunnable { -friend LocIpc; -public: - LocIpcRunnable(LocIpc& locIpc, const string& ipcName) - : mLocIpc(locIpc), mIpcName(ipcName) {} - bool run() override { - if (!mLocIpc.startListeningBlocking(mIpcName)) { - LOC_LOGe("listen to socket failed"); +const char Sock::MSG_ABORT[] = "LocIpc::Sock::ABORT"; +const char Sock::LOC_IPC_HEAD[] = "$MSGLEN$"; +ssize_t Sock::send(const void *buf, size_t len, int flags, const struct sockaddr *destAddr, + socklen_t addrlen) const { + ssize_t rtv = -1; + SOCK_OP_AND_LOG(buf, len, isValid(), rtv, sendto(buf, len, flags, destAddr, addrlen)); + return rtv; +} +ssize_t Sock::recv(const shared_ptr& dataCb, int flags, struct sockaddr *srcAddr, + socklen_t *addrlen, int sid) const { + ssize_t rtv = -1; + if (-1 == sid) { + sid = mSid; + } // else it sid would be connection based socket id for recv + SOCK_OP_AND_LOG(dataCb.get(), mMaxTxSize, isValid(), rtv, + recvfrom(dataCb, sid, flags, srcAddr, addrlen)); + return rtv; +} +ssize_t Sock::sendto(const void *buf, size_t len, int flags, const struct sockaddr *destAddr, + socklen_t addrlen) const { + ssize_t rtv = -1; + if (len <= mMaxTxSize) { + rtv = ::sendto(mSid, buf, len, flags, destAddr, addrlen); + } else { + std::string head(LOC_IPC_HEAD + to_string(len)); + rtv = ::sendto(mSid, head.c_str(), head.length(), flags, destAddr, addrlen); + if (rtv > 0) { + for (size_t offset = 0; offset < len && rtv > 0; offset += rtv) { + rtv = ::sendto(mSid, (char*)buf + offset, min(len - offset, (size_t)mMaxTxSize), + flags, destAddr, addrlen); + } + rtv = (rtv > 0) ? (head.length() + len) : -1; } - - return false; } -private: - LocIpc& mLocIpc; - const string mIpcName; -}; - -bool LocIpc::startListeningNonBlocking(const string& name) { - auto runnable = new LocIpcRunnable(*this, name); - string threadName("LocIpc-"); - threadName.append(name); - return mThread.start(threadName.c_str(), runnable); + return rtv; } +ssize_t Sock::recvfrom(const shared_ptr& dataCb, int sid, int flags, + struct sockaddr *srcAddr, socklen_t *addrlen) const { + ssize_t nBytes = -1; + std::string msg(mMaxTxSize, 0); + + if ((nBytes = ::recvfrom(sid, (void*)msg.data(), msg.size(), flags, srcAddr, addrlen)) > 0) { + if (strncmp(msg.data(), MSG_ABORT, sizeof(MSG_ABORT)) == 0) { + LOC_LOGi("recvd abort msg.data %s", msg.data()); + nBytes = 0; + } else if (strncmp(msg.data(), LOC_IPC_HEAD, sizeof(LOC_IPC_HEAD) - 1)) { + // short message + msg.resize(nBytes); + dataCb->onReceive(msg.data(), nBytes); + } else { + // long message + size_t msgLen = 0; + sscanf(msg.data() + sizeof(LOC_IPC_HEAD) - 1, "%zu", &msgLen); + msg.resize(msgLen); + for (size_t msgLenReceived = 0; (msgLenReceived < msgLen) && (nBytes > 0); + msgLenReceived += nBytes) { + nBytes = ::recvfrom(sid, &(msg[msgLenReceived]), msg.size() - msgLenReceived, + flags, srcAddr, addrlen); + } + if (nBytes > 0) { + nBytes = msgLen; + dataCb->onReceive(msg.data(), nBytes); + } + } + } -bool LocIpc::startListeningBlocking(const string& name) { - bool stopRequested = false; - int fd = socket(AF_UNIX, SOCK_DGRAM, 0); + return nBytes; +} +ssize_t Sock::sendAbort(int flags, const struct sockaddr *destAddr, socklen_t addrlen) { + return send(MSG_ABORT, sizeof(MSG_ABORT), flags, destAddr, addrlen); +} - if (fd < 0) { - LOC_LOGe("create socket error. reason:%s", strerror(errno)); - return false; +class LocIpcLocalSender : public LocIpcSender { +protected: + shared_ptr mSock; + struct sockaddr_un mAddr; + inline virtual bool isOperable() const override { return mSock != nullptr && mSock->isValid(); } + inline virtual ssize_t send(const uint8_t data[], uint32_t length, int32_t /* msgId */) const { + return mSock->send(data, length, 0, (struct sockaddr*)&mAddr, sizeof(mAddr)); } - - if ((unlink(name.c_str()) < 0) && (errno != ENOENT)) { - LOC_LOGw("unlink socket error. reason:%s", strerror(errno)); +public: + inline LocIpcLocalSender(const char* name) : LocIpcSender(), + mSock(make_shared((nullptr == name) ? -1 : (::socket(AF_UNIX, SOCK_DGRAM, 0)))), + mAddr({.sun_family = AF_UNIX, {}}) { + if (mSock != nullptr && mSock->isValid()) { + snprintf(mAddr.sun_path, sizeof(mAddr.sun_path), "%s", name); + } } +}; - struct sockaddr_un addr = { .sun_family = AF_UNIX }; - snprintf(addr.sun_path, sizeof(addr.sun_path), "%s", name.c_str()); - - umask(0157); +class LocIpcLocalRecver : public LocIpcLocalSender, public LocIpcRecver { +protected: + inline virtual ssize_t recv() const override { + socklen_t size = sizeof(mAddr); + return mSock->recv(mDataCb, 0, (struct sockaddr*)&mAddr, &size); + } +public: + inline LocIpcLocalRecver(const shared_ptr& listener, const char* name) : + LocIpcLocalSender(name), LocIpcRecver(listener, *this) { - if (::bind(fd, (struct sockaddr*)&addr, sizeof(addr)) < 0) { - LOC_LOGe("bind socket error. reason:%s", strerror(errno)); - } else { - mIpcFd = fd; - mIpcName = name; + if ((unlink(mAddr.sun_path) < 0) && (errno != ENOENT)) { + LOC_LOGw("unlink socket error. reason:%s", strerror(errno)); + } - // inform that the socket is ready to receive message - onListenerReady(); - - ssize_t nBytes = 0; - string msg = ""; - string abort = LOC_MSG_ABORT; - while (1) { - msg.resize(LOC_MSG_BUF_LEN); - nBytes = ::recvfrom(fd, (void*)(msg.data()), msg.size(), 0, NULL, NULL); - if (nBytes < 0) { - LOC_LOGe("cannot read socket. reason:%s", strerror(errno)); - break; - } else if (0 == nBytes) { - continue; - } + umask(0157); + if (mSock->isValid() && ::bind(mSock->mSid, (struct sockaddr*)&mAddr, sizeof(mAddr)) < 0) { + LOC_LOGe("bind socket error. sock fd: %d, reason: %s", mSock->mSid, strerror(errno)); + mSock->close(); + } + } + inline virtual ~LocIpcLocalRecver() { unlink(mAddr.sun_path); } + inline virtual const char* getName() const override { return mAddr.sun_path; }; + inline virtual void abort() const override { + if (isSendable()) { + mSock->sendAbort(0, (struct sockaddr*)&mAddr, sizeof(mAddr)); + } + } +}; - if (strncmp(msg.data(), abort.c_str(), abort.length()) == 0) { - LOC_LOGi("recvd abort msg.data %s", msg.data()); - stopRequested = true; - break; +class LocIpcInetTcpSender : public LocIpcSender { +protected: + shared_ptr mSock; + const string mName; + sockaddr_in mAddr; + mutable bool mFirstTime; + inline virtual bool isOperable() const override { return mSock != nullptr && mSock->isValid(); } + inline virtual ssize_t send(const uint8_t data[], uint32_t length, int32_t /* msgId */) const { + if (mFirstTime) { + mFirstTime = false; + ::connect(mSock->mSid, (const struct sockaddr*)&mAddr, sizeof(mAddr)); + } + return mSock->send(data, length, 0, (struct sockaddr*)&mAddr, sizeof(mAddr)); + } +public: + inline LocIpcInetTcpSender(const char* name, int32_t port) : LocIpcSender(), + mSock(make_shared((nullptr == name) ? -1 : (::socket(AF_INET, SOCK_STREAM, 0)))), + mName((nullptr == name) ? "" : name), + mAddr({.sin_family=AF_INET, .sin_port=htons(port), .sin_addr={htonl(INADDR_ANY)}}), + mFirstTime(true) { + if (mSock != nullptr && mSock->isValid() && nullptr != name) { + struct hostent* hp = gethostbyname(name); + if (nullptr != hp) { + memcpy((char*)&(mAddr.sin_addr.s_addr), hp->h_addr_list[0], hp->h_length); } + } + } +}; - if (strncmp(msg.data(), LOC_MSG_HEAD, sizeof(LOC_MSG_HEAD) - 1)) { - // short message - msg.resize(nBytes); - onReceive(msg); - } else { - // long message - size_t msgLen = 0; - sscanf(msg.data(), LOC_MSG_HEAD"%zu", &msgLen); - msg.resize(msgLen); - size_t msgLenReceived = 0; - while ((msgLenReceived < msgLen) && (nBytes > 0)) { - nBytes = recvfrom(fd, (void*)&(msg[msgLenReceived]), - msg.size() - msgLenReceived, 0, NULL, NULL); - msgLenReceived += nBytes; - } - if (nBytes > 0) { - onReceive(msg); - } else { - LOC_LOGe("cannot read socket. reason:%s", strerror(errno)); - break; - } +class LocIpcInetTcpRecver : public LocIpcInetTcpSender, public LocIpcRecver { + mutable int32_t mConnFd; +protected: + inline virtual ssize_t recv() const override { + socklen_t size = sizeof(mAddr); + if (-1 == mConnFd && mSock->isValid()) { + if (::listen(mSock->mSid, 3) < 0 || + (mConnFd = accept(mSock->mSid, (struct sockaddr*)&mAddr, &size)) < 0) { + mSock->close(); + mConnFd = -1; } } + return mSock->recv(mDataCb, 0, (struct sockaddr*)&mAddr, &size, mConnFd); } +public: + inline LocIpcInetTcpRecver(const shared_ptr& listener, const char* name, + int32_t port) : + LocIpcInetTcpSender(name, port), LocIpcRecver(listener, *this), mConnFd(-1) { + if (mSock->isValid() && ::bind(mSock->mSid, (struct sockaddr*)&mAddr, sizeof(mAddr)) < 0) { + LOC_LOGe("bind socket error. sock fd: %d, reason: %s", mSock->mSid, strerror(errno)); + mSock->close(); + } + } + inline virtual ~LocIpcInetTcpRecver() { if (-1 != mConnFd) ::close(mConnFd); } + inline virtual const char* getName() const override { return mName.data(); }; + inline virtual void abort() const override { + if (isSendable()) { + mSock->sendAbort(0, (struct sockaddr*)&mAddr, sizeof(mAddr)); + } + } +}; - if (::close(fd)) { - LOC_LOGe("cannot close socket:%s", strerror(errno)); +#ifdef NOT_DEFINED +class LocIpcQcsiSender : public LocIpcSender { +protected: + inline virtual bool isOperable() const override { + return mService != nullptr && mService->isServiceRegistered(); + } + inline virtual ssize_t send(const uint8_t data[], uint32_t length, int32_t msgId) const override { + return mService->sendIndToClient(msgId, data, length); } - unlink(name.c_str()); + inline LocIpcQcsiSender(shared_ptr& service) : mService(service) {} +public: + inline virtual ~LocIpcQcsi() {} +}; - return stopRequested; -} +class LocIpcQcsiRecver : public LocIpcQcsiSender, public LocIpcRecver { +protected: + inline virtual ssize_t recv() const override { return mService->recv(); } +public: + inline LocIpcQcsiRecver(unique_ptr& service) : + LocIpcQcsiSender(service), LocIpcRecver(mService->getDataCallback(), *this) { + } + // only the dele + inline ~LocIpcQcsiRecver() {} + inline virtual const char* getName() const override { return mService->getName().data(); }; + inline virtual void abort() const override { if (isSendable()) mService->abort(); } + shared_ptr getSender() { return make_pare(mService); } +}; +#endif -void LocIpc::stopListening() { - if (mIpcFd >= 0) { - string abort = LOC_MSG_ABORT; - if (!mIpcName.empty()) { - send(mIpcName.c_str(), abort); +class LocIpcRunnable : public LocRunnable { + bool mAbortCalled; + LocIpc& mLocIpc; + unique_ptr mIpcRecver; +public: + inline LocIpcRunnable(LocIpc& locIpc, unique_ptr& ipcRecver) : + mAbortCalled(false), + mLocIpc(locIpc), + mIpcRecver(move(ipcRecver)) {} + inline bool run() override { + if (mIpcRecver != nullptr) { + mLocIpc.startBlockingListening(*(mIpcRecver.get())); + if (!mAbortCalled) { + LOC_LOGw("startListeningBlocking() returned w/o stopBlockingListening() called"); + } } - mIpcFd = -1; + // return false so the calling thread exits while loop + return false; } - if (!mIpcName.empty()) { - mIpcName.clear(); + inline void abort() { + mAbortCalled = true; + if (mIpcRecver != nullptr) { + mIpcRecver->abort(); + } } -} +}; -bool LocIpc::send(const char name[], const string& data) { - return send(name, (const uint8_t*)data.c_str(), data.length()); +bool LocIpc::startNonBlockingListening(unique_ptr& ipcRecver) { + if (ipcRecver != nullptr && ipcRecver->isRecvable()) { + std::string threadName("LocIpc-"); + threadName.append(ipcRecver->getName()); + mRunnable = new LocIpcRunnable(*this, ipcRecver); + return mThread.start(threadName.c_str(), mRunnable); + } else { + LOC_LOGe("ipcRecver is null OR ipcRecver->recvable() is fasle"); + return false; + } } -bool LocIpc::send(const char name[], const uint8_t data[], uint32_t length) { - - bool result = true; - int fd = ::socket(AF_UNIX, SOCK_DGRAM, 0); - if (fd < 0) { - LOC_LOGe("create socket error. reason:%s", strerror(errno)); +bool LocIpc::startBlockingListening(LocIpcRecver& ipcRecver) { + if (ipcRecver.isRecvable()) { + // inform that the socket is ready to receive message + ipcRecver.onListenerReady(); + while (ipcRecver.recvData()); + return true; + } else { + LOC_LOGe("ipcRecver is null OR ipcRecver->recvable() is fasle"); return false; } - - struct sockaddr_un addr = { .sun_family = AF_UNIX }; - snprintf(addr.sun_path, sizeof(addr.sun_path), "%s", name); - - result = sendData(fd, addr, data, length); - - (void)::close(fd); - return result; } +void LocIpc::stopNonBlockingListening() { + if (mRunnable) { + mRunnable->abort(); + mRunnable = nullptr; + } +} -bool LocIpc::sendData(int fd, const sockaddr_un &addr, const uint8_t data[], uint32_t length) { +void LocIpc::stopBlockingListening(LocIpcRecver& ipcRecver) { + if (ipcRecver.isRecvable()) { + ipcRecver.abort(); + } +} - bool result = true; +bool LocIpc::send(LocIpcSender& sender, const uint8_t data[], uint32_t length, int32_t msgId) { + return sender.sendData(data, length, msgId); +} - if (length <= LOC_MSG_BUF_LEN) { - if (::sendto(fd, data, length, 0, - (struct sockaddr*)&addr, sizeof(addr)) < 0) { - LOC_LOGe("cannot send to socket:%s. reason:%s", - addr.sun_path, strerror(errno)); - result = false; - } - } else { - string head = LOC_MSG_HEAD; - head.append(std::to_string(length)); - if (::sendto(fd, head.c_str(), head.length(), 0, - (struct sockaddr*)&addr, sizeof(addr)) < 0) { - LOC_LOGe("cannot send to socket:%s. reason:%s", - addr.sun_path, strerror(errno)); - result = false; - } else { - size_t sentBytes = 0; - while(sentBytes < length) { - size_t partLen = length - sentBytes; - if (partLen > LOC_MSG_BUF_LEN) { - partLen = LOC_MSG_BUF_LEN; - } - ssize_t rv = ::sendto(fd, data + sentBytes, partLen, 0, - (struct sockaddr*)&addr, sizeof(addr)); - if (rv < 0) { - LOC_LOGe("cannot send to socket:%s. reason:%s", - addr.sun_path, strerror(errno)); - result = false; - break; - } - sentBytes += rv; - } - } - } - return result; +shared_ptr LocIpc::getLocIpcLocalSender(const char* localSockName) { + return make_shared(localSockName); +} +unique_ptr LocIpc::getLocIpcLocalRecver(const shared_ptr& listener, + const char* localSockName) { + return make_unique(listener, localSockName); +} +static void* sLibQrtrHandle = nullptr; +static const char* sLibQrtrName = "libloc_socket.so"; +shared_ptr LocIpc::getLocIpcQrtrSender(int service, int instance) { + typedef shared_ptr (*creator_t) (int, int); + static creator_t creator = (creator_t)dlGetSymFromLib(sLibQrtrHandle, sLibQrtrName, + "_ZN8loc_util22createLocIpcQrtrSenderEii"); + return (nullptr == creator) ? nullptr : creator(service, instance); +} +unique_ptr LocIpc::getLocIpcQrtrRecver(const shared_ptr& listener, + int service, int instance) { + typedef unique_ptr (*creator_t)(const shared_ptr&, int, int); + static creator_t creator = (creator_t)dlGetSymFromLib(sLibQrtrHandle, sLibQrtrName, + "_ZN8loc_util22createLocIpcQrtrRecverERKNSt3__110shared_ptrINS_15ILocIpcListenerEEEii"); + return (nullptr == creator) ? nullptr : creator(listener, service, instance); +} +shared_ptr LocIpc::getLocIpcQsockSender(int service, int instance) { + typedef shared_ptr (*creator_t) (int, int); + static creator_t creator = (creator_t)dlGetSymFromLib(sLibQrtrHandle, sLibQrtrName, + "_ZN8loc_util23createLocIpcQsockSenderEii"); + return (nullptr == creator) ? nullptr : creator(service, instance); +} +unique_ptr LocIpc::getLocIpcQsockRecver(const shared_ptr& listener, + int service, int instance) { + typedef unique_ptr (*creator_t)(const shared_ptr&, int, int); + static creator_t creator = (creator_t)dlGetSymFromLib(sLibQrtrHandle, sLibQrtrName, + "_ZN8loc_util23createLocIpcQsockRecverERKSt10shared_ptrINS_15ILocIpcListenerEEii"); + return (nullptr == creator) ? nullptr : creator(listener, service, instance); +} +shared_ptr LocIpc::getLocIpcInetTcpSender(const char* serverName, int32_t port) { + return make_shared(serverName, port); +} +unique_ptr LocIpc::getLocIpcInetTcpRecver(const shared_ptr& listener, + const char* serverName, int32_t port) { + return make_unique(listener, serverName, port); +} +pair, unique_ptr> + LocIpc::getLocIpcQmiLocServiceSenderRecverPair(const shared_ptr& listener, int instance) { + typedef pair, unique_ptr> (*creator_t)(const shared_ptr&, int); + static void* sLibEmuHandle = nullptr; + static creator_t creator = (creator_t)dlGetSymFromLib(sLibEmuHandle, "libloc_emu.so", + "_ZN13QmiLocService41createLocIpcQmiLocServiceSenderRecverPairERKNSt3__110shared_ptrIN8loc_util15ILocIpcListenerEEEi"); + return (nullptr == creator) ? + make_pair, unique_ptr>(nullptr, nullptr) : + creator(listener, instance); } } diff --git a/utils/LocIpc.h b/utils/LocIpc.h index 707df21..20a1c8f 100644 --- a/utils/LocIpc.h +++ b/utils/LocIpc.h @@ -37,35 +37,71 @@ #include #include -using std::string; +using namespace std; namespace loc_util { + +class LocIpcRecver; class LocIpcSender; +class LocIpcRunnable; + +class ILocIpcListener { +protected: + inline virtual ~ILocIpcListener() {} +public: + // LocIpc client can overwrite this function to get notification + // when the socket for LocIpc is ready to receive messages. + inline virtual void onListenerReady() {} + virtual void onReceive(const char* data, uint32_t length)= 0; +}; + class LocIpc { -friend LocIpcSender; public: - inline LocIpc() : mIpcFd(-1) {} - inline virtual ~LocIpc() { stopListening(); } + inline LocIpc() : mRunnable(nullptr) {} + inline virtual ~LocIpc() { + stopNonBlockingListening(); + } + + static shared_ptr + getLocIpcLocalSender(const char* localSockName); + static shared_ptr + getLocIpcInetTcpSender(const char* serverName, int32_t port); + static shared_ptr + getLocIpcQrtrSender(int service, int instance); + static shared_ptr + getLocIpcQsockSender(int service, int instance); + + static unique_ptr + getLocIpcLocalRecver(const shared_ptr& listener, + const char* localSockName); + static unique_ptr + getLocIpcInetTcpRecver(const shared_ptr& listener, + const char* serverName, int32_t port); + static unique_ptr + getLocIpcQrtrRecver(const shared_ptr& listener, + int service, int instance); + static unique_ptr + getLocIpcQsockRecver(const shared_ptr& listener, + int service, int instance); + + static pair, unique_ptr> + getLocIpcQmiLocServiceSenderRecverPair(const shared_ptr& listener, + int instance); // Listen for new messages in current thread. Calling this funciton will - // block current thread. The listening can be stopped by calling stopListening(). - // - // Argument name is the path of the unix local socket to be listened. - // The function will return true on success, and false on failure. - bool startListeningBlocking(const std::string& name); + // block current thread. + // The listening can be stopped by calling stopBlockingListening() passing + // in the same ipcRecver obj handle. + static bool startBlockingListening(LocIpcRecver& ipcRecver); + static void stopBlockingListening(LocIpcRecver& ipcRecver); // Create a new LocThread and listen for new messages in it. // Calling this function will return immediately and won't block current thread. - // The listening can be stopped by calling stopListening(). - // - // Argument name is the path of the unix local socket to be be listened. - // The function will return true on success, and false on failure. - bool startListeningNonBlocking(const std::string& name); - - // Stop listening to new messages. - void stopListening(); + // The listening can be stopped by calling stopNonBlockingListening(). + bool startNonBlockingListening(unique_ptr& ipcRecver); + void stopNonBlockingListening(); // Send out a message. // Call this function to send a message in argument data to socket in argument name. @@ -73,78 +109,70 @@ public: // Argument name contains the name of the target unix socket. data contains the // message to be sent out. Convert your message to a string before calling this function. // The function will return true on success, and false on failure. - static bool send(const char name[], const std::string& data); - static bool send(const char name[], const uint8_t data[], uint32_t length); - -protected: - // Callback function for receiving incoming messages. - // Override this function in your derived class to process incoming messages. - // For each received message, this callback function will be called once. - // This callback function will be called in the calling thread of startListeningBlocking - // or in the new LocThread created by startListeningNonBlocking. - // - // Argument data contains the received message. You need to parse it. - inline virtual void onReceive(const std::string& /*data*/) {} - - // LocIpc client can overwrite this function to get notification - // when the socket for LocIpc is ready to receive messages. - inline virtual void onListenerReady() {} + static bool send(LocIpcSender& sender, const uint8_t data[], + uint32_t length, int32_t msgId = -1); private: - static bool sendData(int fd, const sockaddr_un& addr, - const uint8_t data[], uint32_t length); - - int mIpcFd; LocThread mThread; - string mIpcName; + LocIpcRunnable *mRunnable; }; +/* this is only when client needs to implement Sender / Recver that are not already provided by + the factor methods prvoided by LocIpc. */ + class LocIpcSender { +protected: + LocIpcSender() = default; + virtual ~LocIpcSender() = default; + virtual bool isOperable() const = 0; + virtual ssize_t send(const uint8_t data[], uint32_t length, int32_t msgId) const = 0; public: - // Constructor of LocIpcSender class - // - // Argument destSocket contains the full path name of destination socket. - // This class hides generated fd and destination address object from user. - inline LocIpcSender(const char* destSocket): - LocIpcSender(std::make_shared(::socket(AF_UNIX, SOCK_DGRAM, 0)), destSocket) { - if (mSocket != nullptr && -1 == *mSocket) { - mSocket = nullptr; - } - } - - // Replicate a new LocIpcSender object with new destination socket. - inline LocIpcSender* replicate(const char* destSocket) { - return (nullptr == mSocket) ? nullptr : new LocIpcSender(mSocket, destSocket); - } - - inline ~LocIpcSender() { - if (nullptr != mSocket && mSocket.unique()) { - ::close(*mSocket); - } + inline bool isSendable() const { return isOperable(); } + inline bool sendData(const uint8_t data[], uint32_t length, int32_t msgId) const { + return isSendable() && (send(data, length, msgId) > 0); } +}; - // Send out a message. - // Call this function to send a message - // - // Argument data and length contains the message to be sent out. - // Return true when succeeded - inline bool send(const uint8_t data[], uint32_t length) { - bool rtv = false; - if (nullptr != mSocket && nullptr != data) { - rtv = LocIpc::sendData(*mSocket, mDestAddr, data, length); - } - return rtv; - } +class LocIpcRecver { + LocIpcSender& mIpcSender; +protected: + const shared_ptr mDataCb; + inline LocIpcRecver(const shared_ptr& listener, LocIpcSender& sender) : + mIpcSender(sender), mDataCb(listener) {} + LocIpcRecver(LocIpcRecver const& recver) = delete; + LocIpcRecver& operator=(LocIpcRecver const& recver) = delete; + virtual ssize_t recv() const = 0; +public: + virtual ~LocIpcRecver() = default; + inline bool recvData() const { return isRecvable() && (recv() > 0); } + inline bool isRecvable() const { return mDataCb != nullptr && mIpcSender.isSendable(); } + virtual void onListenerReady() { if (mDataCb != nullptr) mDataCb->onListenerReady(); } + virtual void abort() const = 0; + virtual const char* getName() const = 0; +}; -private: - std::shared_ptr mSocket; - struct sockaddr_un mDestAddr; - - inline LocIpcSender(const std::shared_ptr& mySocket, const char* destSocket) : - mSocket(mySocket), - mDestAddr({.sun_family = AF_UNIX, {}}) { - if ((nullptr != mSocket) && (-1 != *mSocket) && (nullptr != destSocket)) { - snprintf(mDestAddr.sun_path, sizeof(mDestAddr.sun_path), "%s", destSocket); +class Sock { + static const char MSG_ABORT[]; + static const char LOC_IPC_HEAD[]; + const uint32_t mMaxTxSize; + ssize_t sendto(const void *buf, size_t len, int flags, const struct sockaddr *destAddr, + socklen_t addrlen) const; + ssize_t recvfrom(const shared_ptr& dataCb, int sid, int flags, + struct sockaddr *srcAddr, socklen_t *addrlen) const; +public: + int mSid; + inline Sock(int sid, const uint32_t maxTxSize = 8192) : mMaxTxSize(maxTxSize), mSid(sid) {} + inline ~Sock() { close(); } + inline bool isValid() const { return -1 != mSid; } + ssize_t send(const void *buf, size_t len, int flags, const struct sockaddr *destAddr, + socklen_t addrlen) const; + ssize_t recv(const shared_ptr& dataCb, int flags, struct sockaddr *srcAddr, + socklen_t *addrlen, int sid = -1) const; + ssize_t sendAbort(int flags, const struct sockaddr *destAddr, socklen_t addrlen); + inline void close() { + if (isValid()) { + ::close(mSid); + mSid = -1; } } }; diff --git a/utils/Makefile.am b/utils/Makefile.am index 50e1e9a..807916d 100644 --- a/utils/Makefile.am +++ b/utils/Makefile.am @@ -8,7 +8,7 @@ AM_CFLAGS = -Wundef \ -fno-short-enums \ -fpic \ -I./ \ - -std=c++11 \ + -std=c++14 \ $(LOCPLA_CFLAGS) libgps_utils_la_h_sources = \ diff --git a/utils/gps_extended_c.h b/utils/gps_extended_c.h index 800af9b..65218ab 100644 --- a/utils/gps_extended_c.h +++ b/utils/gps_extended_c.h @@ -2163,11 +2163,10 @@ typedef void (*LocAgpsCloseResultCb)(bool isSuccess, AGpsExtType agpsType, void* #define SOCKET_DIR_EHUB "/dev/socket/location/ehub/" #define SOCKET_TO_LOCATION_HAL_DAEMON "/dev/socket/loc_client/hal_daemon" -#define SOCKET_DIR_TO_CLIENT "/dev/socket/loc_client/" -#define SOCKET_TO_LOCATION_CLIENT_BASE "/dev/socket/loc_client/toclient" - -#define DIR_FOR_EXT_AP_LOC_CLIENT "/data/vendor/location/extap_locclient/" -#define FILE_FOR_EXT_AP_LOC_CLIENT_BASE "/data/vendor/location/extap_locclient/client" +#define SOCKET_LOC_CLIENT_DIR "/dev/socket/loc_client/" +#define EAP_LOC_CLIENT_DIR "/data/vendor/location/extap_locclient/" + +#define LOC_CLIENT_NAME_PREFIX "toclient" typedef uint64_t NetworkHandle; #define NETWORK_HANDLE_UNKNOWN ~0 -- cgit v1.2.3 From 331c6d98932dc4b339b92bee65679dd5315c6ec0 Mon Sep 17 00:00:00 2001 From: Saurabh Srivastava Date: Wed, 24 Apr 2019 22:34:24 +0530 Subject: Adding NAVIC support NAVIC constellation support added. Change-Id: I30a61f53089177d4e02b617dc9b785c13e2ef6ee CRs-Fixed: 2399619 --- android/2.0/location_api/LocationUtil.cpp | 3 ++ core/SystemStatus.cpp | 27 +++++++++++-- core/SystemStatus.h | 44 ++++++++++++-------- gnss/GnssAdapter.cpp | 19 +++++++++ location/LocationDataTypes.h | 42 ++++++++++++------- utils/gps_extended_c.h | 67 ++++++++++++++++++++----------- utils/loc_nmea.cpp | 34 +++++++++++++++- 7 files changed, 178 insertions(+), 58 deletions(-) diff --git a/android/2.0/location_api/LocationUtil.cpp b/android/2.0/location_api/LocationUtil.cpp index 6bd5084..38a083a 100644 --- a/android/2.0/location_api/LocationUtil.cpp +++ b/android/2.0/location_api/LocationUtil.cpp @@ -209,6 +209,9 @@ void convertGnssConstellationType(GnssSvType& in, V2_0::GnssConstellationType& o case GNSS_SV_TYPE_GALILEO: out = V2_0::GnssConstellationType::GALILEO; break; + case GNSS_SV_TYPE_NAVIC: + out = V2_0::GnssConstellationType::IRNSS; + break; case GNSS_SV_TYPE_UNKNOWN: default: out = V2_0::GnssConstellationType::UNKNOWN; diff --git a/core/SystemStatus.cpp b/core/SystemStatus.cpp index 524963b..18cb99c 100644 --- a/core/SystemStatus.cpp +++ b/core/SystemStatus.cpp @@ -382,16 +382,19 @@ public: uint32_t mBdsXtraAge; uint32_t mGalXtraAge; uint32_t mQzssXtraAge; + uint32_t mNavicXtraAge; uint32_t mGpsXtraValid; uint32_t mGloXtraValid; uint64_t mBdsXtraValid; uint64_t mGalXtraValid; uint8_t mQzssXtraValid; + uint32_t mNavicXtraValid; }; class SystemStatusPQWP3parser : public SystemStatusNmeaBase { private: + // todo: update for navic once available enum { eTalker = 0, @@ -418,11 +421,13 @@ public: inline uint32_t getBdsXtraAge() { return mP3.mBdsXtraAge; } inline uint32_t getGalXtraAge() { return mP3.mGalXtraAge; } inline uint32_t getQzssXtraAge() { return mP3.mQzssXtraAge; } + inline uint32_t getNavicXtraAge() { return mP3.mNavicXtraAge; } inline uint32_t getGpsXtraValid() { return mP3.mGpsXtraValid; } inline uint32_t getGloXtraValid() { return mP3.mGloXtraValid; } inline uint64_t getBdsXtraValid() { return mP3.mBdsXtraValid; } inline uint64_t getGalXtraValid() { return mP3.mGalXtraValid; } inline uint8_t getQzssXtraValid() { return mP3.mQzssXtraValid; } + inline uint32_t getNavicXtraValid() { return mP3.mNavicXtraValid; } SystemStatusPQWP3parser(const char *str_in, uint32_t len_in) : SystemStatusNmeaBase(str_in, len_in) @@ -431,6 +436,7 @@ public: return; } memset(&mP3, 0, sizeof(mP3)); + // todo: update for navic once available mP3.mXtraValidMask = strtol(mField[eXtraValidMask].c_str(), NULL, 16); mP3.mGpsXtraAge = atoi(mField[eGpsXtraAge].c_str()); mP3.mGloXtraAge = atoi(mField[eGloXtraAge].c_str()); @@ -511,21 +517,25 @@ public: uint64_t mBdsUnknownMask; uint64_t mGalUnknownMask; uint8_t mQzssUnknownMask; + uint32_t mNavicUnknownMask; uint32_t mGpsGoodMask; uint32_t mGloGoodMask; uint64_t mBdsGoodMask; uint64_t mGalGoodMask; uint8_t mQzssGoodMask; + uint32_t mNavicGoodMask; uint32_t mGpsBadMask; uint32_t mGloBadMask; uint64_t mBdsBadMask; uint64_t mGalBadMask; uint8_t mQzssBadMask; + uint32_t mNavicBadMask; }; class SystemStatusPQWP5parser : public SystemStatusNmeaBase { private: + // todo: update for navic once available enum { eTalker = 0, @@ -555,16 +565,19 @@ public: inline uint64_t getBdsUnknownMask() { return mP5.mBdsUnknownMask; } inline uint64_t getGalUnknownMask() { return mP5.mGalUnknownMask; } inline uint8_t getQzssUnknownMask() { return mP5.mQzssUnknownMask; } + inline uint32_t getNavicUnknownMask() { return mP5.mNavicUnknownMask; } inline uint32_t getGpsGoodMask() { return mP5.mGpsGoodMask; } inline uint32_t getGloGoodMask() { return mP5.mGloGoodMask; } inline uint64_t getBdsGoodMask() { return mP5.mBdsGoodMask; } inline uint64_t getGalGoodMask() { return mP5.mGalGoodMask; } inline uint8_t getQzssGoodMask() { return mP5.mQzssGoodMask; } + inline uint32_t getNavicGoodMask() { return mP5.mNavicGoodMask; } inline uint32_t getGpsBadMask() { return mP5.mGpsBadMask; } inline uint32_t getGloBadMask() { return mP5.mGloBadMask; } inline uint64_t getBdsBadMask() { return mP5.mBdsBadMask; } inline uint64_t getGalBadMask() { return mP5.mGalBadMask; } inline uint8_t getQzssBadMask() { return mP5.mQzssBadMask; } + inline uint32_t getNavicBadMask() { return mP5.mNavicBadMask; } SystemStatusPQWP5parser(const char *str_in, uint32_t len_in) : SystemStatusNmeaBase(str_in, len_in) @@ -573,6 +586,7 @@ public: return; } memset(&mP5, 0, sizeof(mP5)); + // todo: update for navic once available mP5.mGpsUnknownMask = strtol(mField[eGpsUnknownMask].c_str(), NULL, 16); mP5.mGloUnknownMask = strtol(mField[eGloUnknownMask].c_str(), NULL, 16); mP5.mBdsUnknownMask = strtol(mField[eBdsUnknownMask].c_str(), NULL, 16); @@ -971,11 +985,13 @@ SystemStatusXtra::SystemStatusXtra(const SystemStatusPQWP3& nmea) : mBdsXtraAge(nmea.mBdsXtraAge), mGalXtraAge(nmea.mGalXtraAge), mQzssXtraAge(nmea.mQzssXtraAge), + mNavicXtraAge(nmea.mNavicXtraAge), mGpsXtraValid(nmea.mGpsXtraValid), mGloXtraValid(nmea.mGloXtraValid), mBdsXtraValid(nmea.mBdsXtraValid), mGalXtraValid(nmea.mGalXtraValid), - mQzssXtraValid(nmea.mQzssXtraValid) + mQzssXtraValid(nmea.mQzssXtraValid), + mNavicXtraValid(nmea.mNavicXtraValid) { } @@ -987,11 +1003,13 @@ bool SystemStatusXtra::equals(const SystemStatusXtra& peer) (mBdsXtraAge != peer.mBdsXtraAge) || (mGalXtraAge != peer.mGalXtraAge) || (mQzssXtraAge != peer.mQzssXtraAge) || + (mNavicXtraAge != peer.mNavicXtraAge) || (mGpsXtraValid != peer.mGpsXtraValid) || (mGloXtraValid != peer.mGloXtraValid) || (mBdsXtraValid != peer.mBdsXtraValid) || (mGalXtraValid != peer.mGalXtraValid) || - (mQzssXtraValid != peer.mQzssXtraValid)) { + (mQzssXtraValid != peer.mQzssXtraValid) || + (mNavicXtraValid != peer.mNavicXtraValid)) { return false; } return true; @@ -1060,16 +1078,19 @@ SystemStatusSvHealth::SystemStatusSvHealth(const SystemStatusPQWP5& nmea) : mBdsUnknownMask(nmea.mBdsUnknownMask), mGalUnknownMask(nmea.mGalUnknownMask), mQzssUnknownMask(nmea.mQzssUnknownMask), + mNavicUnknownMask(nmea.mNavicUnknownMask), mGpsGoodMask(nmea.mGpsGoodMask), mGloGoodMask(nmea.mGloGoodMask), mBdsGoodMask(nmea.mBdsGoodMask), mGalGoodMask(nmea.mGalGoodMask), mQzssGoodMask(nmea.mQzssGoodMask), + mNavicGoodMask(nmea.mNavicGoodMask), mGpsBadMask(nmea.mGpsBadMask), mGloBadMask(nmea.mGloBadMask), mBdsBadMask(nmea.mBdsBadMask), mGalBadMask(nmea.mGalBadMask), - mQzssBadMask(nmea.mQzssBadMask) + mQzssBadMask(nmea.mQzssBadMask), + mNavicBadMask(nmea.mNavicBadMask) { } diff --git a/core/SystemStatus.h b/core/SystemStatus.h index 0dbcf91..f3467e2 100644 --- a/core/SystemStatus.h +++ b/core/SystemStatus.h @@ -44,20 +44,22 @@ #include -#define GPS_MIN (1) //1-32 -#define SBAS_MIN (33) -#define GLO_MIN (65) //65-88 -#define QZSS_MIN (193) //193-197 -#define BDS_MIN (201) //201-237 -#define GAL_MIN (301) //301-336 - -#define GPS_NUM (32) -#define SBAS_NUM (32) -#define GLO_NUM (24) -#define QZSS_NUM (5) -#define BDS_NUM (37) -#define GAL_NUM (36) -#define SV_ALL_NUM (GPS_NUM+GLO_NUM+QZSS_NUM+BDS_NUM+GAL_NUM) //=134 +#define GPS_MIN (1) //1-32 +#define SBAS_MIN (33) +#define GLO_MIN (65) //65-88 +#define QZSS_MIN (193) //193-197 +#define BDS_MIN (201) //201-237 +#define GAL_MIN (301) //301-336 +#define NAVIC_MIN (401) //401-414 + +#define GPS_NUM (32) +#define SBAS_NUM (32) +#define GLO_NUM (24) +#define QZSS_NUM (5) +#define BDS_NUM (37) +#define GAL_NUM (36) +#define NAVIC_NUM (14) +#define SV_ALL_NUM (GPS_NUM+GLO_NUM+QZSS_NUM+BDS_NUM+GAL_NUM+NAVIC_NUM) //=148 namespace loc_core { @@ -258,11 +260,13 @@ public: uint32_t mBdsXtraAge; uint32_t mGalXtraAge; uint32_t mQzssXtraAge; + uint32_t mNavicXtraAge; uint32_t mGpsXtraValid; uint32_t mGloXtraValid; uint64_t mBdsXtraValid; uint64_t mGalXtraValid; uint8_t mQzssXtraValid; + uint32_t mNavicXtraValid; inline SystemStatusXtra() : mXtraValidMask(0), mGpsXtraAge(0), @@ -270,11 +274,13 @@ public: mBdsXtraAge(0), mGalXtraAge(0), mQzssXtraAge(0), + mNavicXtraAge(0), mGpsXtraValid(0), mGloXtraValid(0), mBdsXtraValid(0ULL), mGalXtraValid(0ULL), - mQzssXtraValid(0) {} + mQzssXtraValid(0), + mNavicXtraValid(0) {} inline SystemStatusXtra(const SystemStatusPQWP3& nmea); bool equals(const SystemStatusXtra& peer); void dump(void); @@ -309,32 +315,38 @@ public: uint64_t mBdsUnknownMask; uint64_t mGalUnknownMask; uint8_t mQzssUnknownMask; + uint32_t mNavicUnknownMask; uint32_t mGpsGoodMask; uint32_t mGloGoodMask; uint64_t mBdsGoodMask; uint64_t mGalGoodMask; uint8_t mQzssGoodMask; + uint32_t mNavicGoodMask; uint32_t mGpsBadMask; uint32_t mGloBadMask; uint64_t mBdsBadMask; uint64_t mGalBadMask; uint8_t mQzssBadMask; + uint32_t mNavicBadMask; inline SystemStatusSvHealth() : mGpsUnknownMask(0), mGloUnknownMask(0), mBdsUnknownMask(0ULL), mGalUnknownMask(0ULL), mQzssUnknownMask(0), + mNavicUnknownMask(0), mGpsGoodMask(0), mGloGoodMask(0), mBdsGoodMask(0ULL), mGalGoodMask(0ULL), mQzssGoodMask(0), + mNavicGoodMask(0), mGpsBadMask(0), mGloBadMask(0), mBdsBadMask(0ULL), mGalBadMask(0ULL), - mQzssBadMask(0) {} + mQzssBadMask(0), + mNavicBadMask(0) {} inline SystemStatusSvHealth(const SystemStatusPQWP5& nmea); bool equals(const SystemStatusSvHealth& peer); void dump(void); diff --git a/gnss/GnssAdapter.cpp b/gnss/GnssAdapter.cpp index 549c845..eaf8878 100644 --- a/gnss/GnssAdapter.cpp +++ b/gnss/GnssAdapter.cpp @@ -3364,6 +3364,11 @@ GnssAdapter::reportSv(GnssSvNotification& svNotify) // SV id passed to here by LocApi is 1-based. svNotify.gnssSvs[i].svId += (QZSS_SV_PRN_MIN - 1); break; + case GNSS_SV_TYPE_NAVIC: + if (mGnssSvIdUsedInPosAvail) { + svUsedIdMask = mGnssSvIdUsedInPosition.navic_sv_used_ids_mask; + } + break; default: svUsedIdMask = 0; break; @@ -4384,6 +4389,19 @@ void GnssAdapter::convertSatelliteInfo(std::vector& out, server_perdiction_age = (float)(in.mXtra.back().mGalXtraAge); } break; + case GNSS_SV_TYPE_NAVIC: + svid_min = GNSS_BUGREPORT_NAVIC_MIN; + svid_num = NAVIC_NUM; + svid_idx = GPS_NUM+GLO_NUM+QZSS_NUM+BDS_NUM+GAL_NUM; + if (!in.mSvHealth.empty()) { + eph_health_good_mask = in.mSvHealth.back().mNavicGoodMask; + eph_health_bad_mask = in.mSvHealth.back().mNavicBadMask; + } + if (!in.mXtra.empty()) { + server_perdiction_available_mask = in.mXtra.back().mNavicXtraValid; + server_perdiction_age = (float)(in.mXtra.back().mNavicXtraAge); + } + break; default: return; } @@ -4541,6 +4559,7 @@ bool GnssAdapter::getDebugReport(GnssDebugReport& r) convertSatelliteInfo(r.mSatelliteInfo, GNSS_SV_TYPE_QZSS, reports); convertSatelliteInfo(r.mSatelliteInfo, GNSS_SV_TYPE_BEIDOU, reports); convertSatelliteInfo(r.mSatelliteInfo, GNSS_SV_TYPE_GALILEO, reports); + convertSatelliteInfo(r.mSatelliteInfo, GNSS_SV_TYPE_NAVIC, reports); LOC_LOGV("getDebugReport - satellite=%zu", r.mSatelliteInfo.size()); return true; diff --git a/location/LocationDataTypes.h b/location/LocationDataTypes.h index 0c8e157..ad85cd7 100644 --- a/location/LocationDataTypes.h +++ b/location/LocationDataTypes.h @@ -41,12 +41,13 @@ #define GNSS_MEASUREMENTS_MAX (128) #define GNSS_UTC_TIME_OFFSET (3657) -#define GNSS_BUGREPORT_GPS_MIN (1) -#define GNSS_BUGREPORT_SBAS_MIN (120) -#define GNSS_BUGREPORT_GLO_MIN (1) -#define GNSS_BUGREPORT_QZSS_MIN (193) -#define GNSS_BUGREPORT_BDS_MIN (1) -#define GNSS_BUGREPORT_GAL_MIN (1) +#define GNSS_BUGREPORT_GPS_MIN (1) +#define GNSS_BUGREPORT_SBAS_MIN (120) +#define GNSS_BUGREPORT_GLO_MIN (1) +#define GNSS_BUGREPORT_QZSS_MIN (193) +#define GNSS_BUGREPORT_BDS_MIN (1) +#define GNSS_BUGREPORT_GAL_MIN (1) +#define GNSS_BUGREPORT_NAVIC_MIN (1) #define GNSS_MAX_NAME_LENGTH (8) @@ -349,6 +350,7 @@ typedef enum { GNSS_SV_TYPE_QZSS, GNSS_SV_TYPE_BEIDOU, GNSS_SV_TYPE_GALILEO, + GNSS_SV_TYPE_NAVIC, } GnssSvType; typedef enum { @@ -518,6 +520,7 @@ typedef enum { GNSS_AIDING_DATA_SV_TYPE_QZSS_BIT = (1<<2), GNSS_AIDING_DATA_SV_TYPE_BEIDOU_BIT = (1<<3), GNSS_AIDING_DATA_SV_TYPE_GALILEO_BIT = (1<<4), + GNSS_AIDING_DATA_SV_TYPE_NAVIC_BIT = (1<<5), } GnssAidingDataSvTypeBits; /* Gnss constellation type mask */ @@ -528,13 +531,15 @@ typedef enum { GNSS_CONSTELLATION_TYPE_QZSS_BIT = (1<<2), GNSS_CONSTELLATION_TYPE_BEIDOU_BIT = (1<<3), GNSS_CONSTELLATION_TYPE_GALILEO_BIT = (1<<4), - GNSS_CONSTELLATION_TYPE_SBAS_BIT = (1<<5) + GNSS_CONSTELLATION_TYPE_SBAS_BIT = (1<<5), + GNSS_CONSTELLATION_TYPE_NAVIC_BIT = (1<<6) } GnssConstellationTypeBits; #define GNSS_CONSTELLATION_TYPE_MASK_ALL\ (GNSS_CONSTELLATION_TYPE_GPS_BIT | GNSS_CONSTELLATION_TYPE_GLONASS_BIT |\ GNSS_CONSTELLATION_TYPE_QZSS_BIT | GNSS_CONSTELLATION_TYPE_BEIDOU_BIT |\ - GNSS_CONSTELLATION_TYPE_GALILEO_BIT | GNSS_CONSTELLATION_TYPE_SBAS_BIT) + GNSS_CONSTELLATION_TYPE_GALILEO_BIT | GNSS_CONSTELLATION_TYPE_SBAS_BIT |\ + GNSS_CONSTELLATION_TYPE_NAVIC_BIT) /** GNSS Signal Type and RF Band */ typedef uint32_t GnssSignalTypeMask; @@ -574,7 +579,9 @@ typedef enum { /** QZSS L5 RF Band */ GNSS_SIGNAL_QZSS_L5 = (1<<16), /** SBAS L1 RF Band */ - GNSS_SIGNAL_SBAS_L1 = (1<<17) + GNSS_SIGNAL_SBAS_L1 = (1<<17), + /** NAVIC L5 RF Band */ + GNSS_SIGNAL_NAVIC_L5 = (1<<18) } GnssSignalTypeBits; #define GNSS_SIGNAL_TYPE_MASK_ALL\ @@ -583,7 +590,8 @@ typedef enum { GNSS_SIGNAL_GALILEO_E1 | GNSS_SIGNAL_GALILEO_E5A | GNSS_SIGNAL_GALILEO_E5B |\ GNSS_SIGNAL_BEIDOU_B1I | GNSS_SIGNAL_BEIDOU_B1C | GNSS_SIGNAL_BEIDOU_B2I|\ GNSS_SIGNAL_BEIDOU_B2AI | GNSS_SIGNAL_QZSS_L1CA | GNSS_SIGNAL_QZSS_L1S |\ - GNSS_SIGNAL_QZSS_L2| GNSS_SIGNAL_QZSS_L5 | GNSS_SIGNAL_SBAS_L1) + GNSS_SIGNAL_QZSS_L2| GNSS_SIGNAL_QZSS_L5 | GNSS_SIGNAL_SBAS_L1 |\ + GNSS_SIGNAL_NAVIC_L5) typedef enum { @@ -599,7 +607,9 @@ typedef enum /**< GLONASS satellite. */ GNSS_LOC_SV_SYSTEM_BDS = 5, /**< BDS satellite. */ - GNSS_LOC_SV_SYSTEM_QZSS = 6 + GNSS_LOC_SV_SYSTEM_QZSS = 6, + /**< QZSS satellite. */ + GNSS_LOC_SV_SYSTEM_NAVIC = 7 /**< QZSS satellite. */ } Gnss_LocSvSystemEnumType; @@ -622,7 +632,8 @@ typedef enum { GNSS_LOC_SIGNAL_TYPE_QZSS_L2C_L = 15, /**< QZSS L2C_L RF Band */ GNSS_LOC_SIGNAL_TYPE_QZSS_L5_Q = 16, /**< QZSS L5_Q RF Band */ GNSS_LOC_SIGNAL_TYPE_SBAS_L1_CA = 17, /**< SBAS L1_CA RF Band */ - GNSS_LOC_MAX_NUMBER_OF_SIGNAL_TYPES = 18 /**< Maximum number of signal types */ + GNSS_LOC_SIGNAL_TYPE_NAVIC_L5 = 18, /**< NAVIC L5 RF Band */ + GNSS_LOC_MAX_NUMBER_OF_SIGNAL_TYPES = 19 /**< Maximum number of signal types */ } Gnss_LocSignalEnumType; typedef uint64_t GnssDataMask; @@ -799,6 +810,7 @@ typedef struct { uint64_t galSvUsedIdsMask; uint64_t bdsSvUsedIdsMask; uint64_t qzssSvUsedIdsMask; + uint64_t navicSvUsedIdsMask; } GnssLocationSvUsedInPosition; typedef struct { @@ -812,7 +824,8 @@ typedef struct { For SBAS: 120 to 151 For QZSS-L1CA:193 to 197 For BDS: 201 to 237 - For GAL: 301 to 336 */ + For GAL: 301 to 336 + For NAVIC: 401 to 414 */ uint16_t gnssSvId; } GnssMeasUsageInfo; @@ -907,7 +920,8 @@ typedef union { GnssSystemTimeStructType galSystemTime; GnssSystemTimeStructType bdsSystemTime; GnssSystemTimeStructType qzssSystemTime; - GnssGloTimeStructType gloSystemTime; + GnssGloTimeStructType gloSystemTime; + GnssSystemTimeStructType navicSystemTime; } SystemTimeStructUnion; /** Time applicability of PVT report */ typedef struct { diff --git a/utils/gps_extended_c.h b/utils/gps_extended_c.h index 65218ab..70aa1be 100644 --- a/utils/gps_extended_c.h +++ b/utils/gps_extended_c.h @@ -434,6 +434,8 @@ typedef uint32_t GnssAdditionalSystemInfoMask; #define BDS_SV_PRN_MAX 235 #define GAL_SV_PRN_MIN 301 #define GAL_SV_PRN_MAX 336 +#define NAVIC_SV_PRN_MIN 401 +#define NAVIC_SV_PRN_MAX 414 typedef uint32_t LocPosTechMask; #define LOC_POS_TECH_MASK_DEFAULT ((LocPosTechMask)0x00000000) @@ -467,6 +469,7 @@ typedef struct { uint64_t gal_sv_used_ids_mask; uint64_t bds_sv_used_ids_mask; uint64_t qzss_sv_used_ids_mask; + uint64_t navic_sv_used_ids_mask; } GnssSvUsedInPosition; typedef struct { @@ -594,6 +597,8 @@ typedef uint32_t GnssSignalTypeMask; #define GNSS_SIGNAL_QZSS_L5 ((GnssSignalTypeMask)0x00010000ul) /** SBAS L1 RF Band */ #define GNSS_SIGNAL_SBAS_L1 ((GnssSignalTypeMask)0x00020000ul) +/** NAVIC L5 RF Band */ +#define GNSS_SIGNAL_NAVIC_L5 ((GnssSignalTypeMask)0x00040000ul) typedef uint16_t GnssMeasUsageStatusBitMask; /** Used in fix */ @@ -1352,26 +1357,32 @@ typedef struct typedef uint64_t GpsSvMeasHeaderFlags; -#define GNSS_SV_MEAS_HEADER_HAS_LEAP_SECOND 0x00000001 -#define GNSS_SV_MEAS_HEADER_HAS_CLOCK_FREQ 0x00000002 -#define GNSS_SV_MEAS_HEADER_HAS_AP_TIMESTAMP 0x00000004 -#define GNSS_SV_MEAS_HEADER_HAS_GPS_GLO_INTER_SYSTEM_BIAS 0x00000008 -#define GNSS_SV_MEAS_HEADER_HAS_GPS_BDS_INTER_SYSTEM_BIAS 0x00000010 -#define GNSS_SV_MEAS_HEADER_HAS_GPS_GAL_INTER_SYSTEM_BIAS 0x00000020 -#define GNSS_SV_MEAS_HEADER_HAS_BDS_GLO_INTER_SYSTEM_BIAS 0x00000040 -#define GNSS_SV_MEAS_HEADER_HAS_GAL_GLO_INTER_SYSTEM_BIAS 0x00000080 -#define GNSS_SV_MEAS_HEADER_HAS_GAL_BDS_INTER_SYSTEM_BIAS 0x00000100 -#define GNSS_SV_MEAS_HEADER_HAS_GPS_SYSTEM_TIME 0x00000200 -#define GNSS_SV_MEAS_HEADER_HAS_GAL_SYSTEM_TIME 0x00000400 -#define GNSS_SV_MEAS_HEADER_HAS_BDS_SYSTEM_TIME 0x00000800 -#define GNSS_SV_MEAS_HEADER_HAS_QZSS_SYSTEM_TIME 0x00001000 -#define GNSS_SV_MEAS_HEADER_HAS_GLO_SYSTEM_TIME 0x00002000 -#define GNSS_SV_MEAS_HEADER_HAS_GPS_SYSTEM_TIME_EXT 0x00004000 -#define GNSS_SV_MEAS_HEADER_HAS_GAL_SYSTEM_TIME_EXT 0x00008000 -#define GNSS_SV_MEAS_HEADER_HAS_BDS_SYSTEM_TIME_EXT 0x00010000 -#define GNSS_SV_MEAS_HEADER_HAS_QZSS_SYSTEM_TIME_EXT 0x00020000 -#define GNSS_SV_MEAS_HEADER_HAS_GPSL1L5_TIME_BIAS 0x00040000 -#define GNSS_SV_MEAS_HEADER_HAS_GALE1E5A_TIME_BIAS 0x00080000 +#define GNSS_SV_MEAS_HEADER_HAS_LEAP_SECOND 0x00000001 +#define GNSS_SV_MEAS_HEADER_HAS_CLOCK_FREQ 0x00000002 +#define GNSS_SV_MEAS_HEADER_HAS_AP_TIMESTAMP 0x00000004 +#define GNSS_SV_MEAS_HEADER_HAS_GPS_GLO_INTER_SYSTEM_BIAS 0x00000008 +#define GNSS_SV_MEAS_HEADER_HAS_GPS_BDS_INTER_SYSTEM_BIAS 0x00000010 +#define GNSS_SV_MEAS_HEADER_HAS_GPS_GAL_INTER_SYSTEM_BIAS 0x00000020 +#define GNSS_SV_MEAS_HEADER_HAS_BDS_GLO_INTER_SYSTEM_BIAS 0x00000040 +#define GNSS_SV_MEAS_HEADER_HAS_GAL_GLO_INTER_SYSTEM_BIAS 0x00000080 +#define GNSS_SV_MEAS_HEADER_HAS_GAL_BDS_INTER_SYSTEM_BIAS 0x00000100 +#define GNSS_SV_MEAS_HEADER_HAS_GPS_SYSTEM_TIME 0x00000200 +#define GNSS_SV_MEAS_HEADER_HAS_GAL_SYSTEM_TIME 0x00000400 +#define GNSS_SV_MEAS_HEADER_HAS_BDS_SYSTEM_TIME 0x00000800 +#define GNSS_SV_MEAS_HEADER_HAS_QZSS_SYSTEM_TIME 0x00001000 +#define GNSS_SV_MEAS_HEADER_HAS_GLO_SYSTEM_TIME 0x00002000 +#define GNSS_SV_MEAS_HEADER_HAS_GPS_SYSTEM_TIME_EXT 0x00004000 +#define GNSS_SV_MEAS_HEADER_HAS_GAL_SYSTEM_TIME_EXT 0x00008000 +#define GNSS_SV_MEAS_HEADER_HAS_BDS_SYSTEM_TIME_EXT 0x00010000 +#define GNSS_SV_MEAS_HEADER_HAS_QZSS_SYSTEM_TIME_EXT 0x00020000 +#define GNSS_SV_MEAS_HEADER_HAS_GPSL1L5_TIME_BIAS 0x00040000 +#define GNSS_SV_MEAS_HEADER_HAS_GALE1E5A_TIME_BIAS 0x00080000 +#define GNSS_SV_MEAS_HEADER_HAS_GPS_NAVIC_INTER_SYSTEM_BIAS 0x00100000 +#define GNSS_SV_MEAS_HEADER_HAS_GAL_NAVIC_INTER_SYSTEM_BIAS 0x00200000 +#define GNSS_SV_MEAS_HEADER_HAS_GLO_NAVIC_INTER_SYSTEM_BIAS 0x00400000 +#define GNSS_SV_MEAS_HEADER_HAS_BDS_NAVIC_INTER_SYSTEM_BIAS 0x00800000 +#define GNSS_SV_MEAS_HEADER_HAS_NAVIC_SYSTEM_TIME 0x01000000 +#define GNSS_SV_MEAS_HEADER_HAS_NAVIC_SYSTEM_TIME_EXT 0x02000000 @@ -1393,6 +1404,10 @@ typedef struct Gnss_InterSystemBiasStructType bdsGloInterSystemBias; Gnss_InterSystemBiasStructType galGloInterSystemBias; Gnss_InterSystemBiasStructType galBdsInterSystemBias; + Gnss_InterSystemBiasStructType gpsNavicInterSystemBias; + Gnss_InterSystemBiasStructType galNavicInterSystemBias; + Gnss_InterSystemBiasStructType gloNavicInterSystemBias; + Gnss_InterSystemBiasStructType bdsNavicInterSystemBias; Gnss_InterSystemBiasStructType gpsL1L5TimeBias; Gnss_InterSystemBiasStructType galE1E5aTimeBias; @@ -1400,6 +1415,7 @@ typedef struct GnssSystemTimeStructType galSystemTime; GnssSystemTimeStructType bdsSystemTime; GnssSystemTimeStructType qzssSystemTime; + GnssSystemTimeStructType navicSystemTime; GnssGloTimeStructType gloSystemTime; /** GPS system RTC time information. */ @@ -1410,6 +1426,8 @@ typedef struct Gnss_LocGnssTimeExtStructType bdsSystemTimeExt; /** QZSS system RTC time information. */ Gnss_LocGnssTimeExtStructType qzssSystemTimeExt; + /** NAVIC system RTC time information. */ + Gnss_LocGnssTimeExtStructType navicSystemTimeExt; } GnssSvMeasurementHeader; @@ -2025,10 +2043,11 @@ typedef struct /* Mask indicating enabled or disabled constellations */ typedef uint64_t GnssSvTypesMask; typedef enum { - GNSS_SV_TYPES_MASK_GLO_BIT = (1<<0), - GNSS_SV_TYPES_MASK_BDS_BIT = (1<<1), - GNSS_SV_TYPES_MASK_QZSS_BIT = (1<<2), - GNSS_SV_TYPES_MASK_GAL_BIT = (1<<3), + GNSS_SV_TYPES_MASK_GLO_BIT = (1<<0), + GNSS_SV_TYPES_MASK_BDS_BIT = (1<<1), + GNSS_SV_TYPES_MASK_QZSS_BIT = (1<<2), + GNSS_SV_TYPES_MASK_GAL_BIT = (1<<3), + GNSS_SV_TYPES_MASK_NAVIC_BIT = (1<<4), } GnssSvTypesMaskBits; /* This SV Type config is injected directly to GNSS Adapter diff --git a/utils/loc_nmea.cpp b/utils/loc_nmea.cpp index 9cd3472..45b4f06 100644 --- a/utils/loc_nmea.cpp +++ b/utils/loc_nmea.cpp @@ -123,6 +123,7 @@ typedef struct loc_sv_cache_info_s uint32_t gal_used_mask; uint32_t qzss_used_mask; uint32_t bds_used_mask; + uint32_t navic_used_mask; uint32_t gps_l1_count; uint32_t gps_l5_count; uint32_t glo_g1_count; @@ -133,6 +134,7 @@ typedef struct loc_sv_cache_info_s uint32_t qzss_l5_count; uint32_t bds_b1_count; uint32_t bds_b2_count; + uint32_t navic_l5_count; float hdop; float pdop; float vdop; @@ -324,6 +326,9 @@ static uint32_t convert_signalType_to_signalId(GnssSignalTypeMask signalType) case GNSS_SIGNAL_BEIDOU_B2AI: signalId = SIGNAL_ID_BDS_B2A; break; + case GNSS_SIGNAL_NAVIC_L5: + signalId = SIGNAL_ID_NAVIC_L5SPS; + break; default: signalId = SIGNAL_ID_ALL_SIGNALS; } @@ -418,6 +423,16 @@ static loc_nmea_sv_meta* loc_nmea_sv_meta_init(loc_nmea_sv_meta& sv_meta, sv_meta.svCount = sv_cache_info.bds_b2_count; } break; + case GNSS_SV_TYPE_NAVIC: + sv_meta.talker[0] = 'G'; + sv_meta.talker[1] = 'I'; + 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; + } + break; default: LOC_LOGE("NMEA Error unknow constellation type: %d", svType); return NULL; @@ -428,7 +443,8 @@ static loc_nmea_sv_meta* loc_nmea_sv_meta_init(loc_nmea_sv_meta& sv_meta, (sv_cache_info.glo_used_mask ? 1 : 0) + (sv_cache_info.gal_used_mask ? 1 : 0) + (sv_cache_info.qzss_used_mask ? 1 : 0) + - (sv_cache_info.bds_used_mask ? 1 : 0) > 1) + (sv_cache_info.bds_used_mask ? 1 : 0) + + (sv_cache_info.navic_used_mask ? 1 : 0) > 1) { // If GPS, GLONASS, Galileo, QZSS, BDS etc. are combined // to obtain the reported position solution, @@ -701,6 +717,9 @@ static void loc_nmea_generate_GSV(const GnssSvNotification &svNotify, case GNSS_SV_TYPE_SBAS: signalType = GNSS_SIGNAL_SBAS_L1; break; + case GNSS_SV_TYPE_NAVIC: + signalType = GNSS_SIGNAL_NAVIC_L5; + break; default: LOC_LOGE("NMEA Error unknow constellation type: %d", svNotify.gnssSvs[svNumber - 1].type); @@ -1815,6 +1834,19 @@ 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) + { + // 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 & + GNSS_SV_OPTIONS_USED_IN_FIX_BIT)) + { + sv_cache_info.navic_used_mask |= (1 << (svNotify.gnssSvs[svNumber - 1].svId - 1)); + } + // GNSS_SIGNAL_NAVIC_L5 is the only signal type for NAVIC + sv_cache_info.navic_l5_count++; + } } loc_nmea_sv_meta sv_meta; -- cgit v1.2.3