diff --git a/gnss/GnssAdapter.cpp b/gnss/GnssAdapter.cpp index cfb10e27..6d73ed68 100644 --- a/gnss/GnssAdapter.cpp +++ b/gnss/GnssAdapter.cpp @@ -3010,6 +3010,10 @@ GnssAdapter::updateClientsEventMask() LOC_LOGd("GNSS Bands supported"); mask |= LOC_API_ADAPTER_BIT_GNSS_BANDS_SUPPORTED; } + if (it->second.svEphemerisCb != nullptr) { + LOC_LOGd("GNSS EPH supported"); + mask |= LOC_API_ADAPTER_BIT_GNSS_SV_EPHEMERIS_REPORT; + } } /* @@ -3271,7 +3275,8 @@ GnssAdapter::hasCallbacksToStartTracking(LocationAPI* client) it->second.engineLocationsInfoCb || it->second.gnssMeasurementsCb || it->second.gnssNHzMeasurementsCb || it->second.gnssDataCb || it->second.gnssSvCb || it->second.gnssNmeaCb || it->second.gnssDcReportCb || - it->second.engineNmeaCb || it->second.gnssSignalTypesCb) { + it->second.engineNmeaCb || it->second.gnssSignalTypesCb || + it->second.svEphemerisCb) { allowed = true; } else { LOC_LOGi("missing right callback to start tracking") @@ -5575,9 +5580,232 @@ GnssAdapter::reportSvPolynomialEvent(GnssSvPolynomial &svPolynomial) mEngHubProxy->gnssReportSvPolynomial(svPolynomial); } +bool GnssAdapter::isEphNetworkBased(const GnssEphCommon& commanEphRpt) +{ + if (GNSS_EPH_ACTION_UPDATE_SRC_NETWORK_V02 == commanEphRpt.updateAction || + GNSS_EPH_ACTION_DELETE_SRC_NETWORK_V02 == commanEphRpt.updateAction) { + return true; + } + return false; +} + +void GnssAdapter::convertGpsEphemeris(const GpsEphemerisResponse& ephRpt, + GpsEphemerisResponse& halEph) { + /** Keep count of number of OTA based ephemeris to be reported to LCA */ + uint16_t numEph = 0; + uint16_t maxNumEph = std::min(ephRpt.numOfEphemeris, + (uint16_t)GNSS_EPHEMERIS_LIST_MAX_SIZE_V02); + + for (uint16_t idx = 0; idx < maxNumEph; idx++) { + if (isEphNetworkBased(ephRpt.gpsEphemerisData[idx].commonEphemerisData)) { + continue; + } + halEph.gpsEphemerisData[numEph] = ephRpt.gpsEphemerisData[idx]; + numEph++; + } + + halEph.numOfEphemeris = numEph; +} + +void GnssAdapter::convertGalEphemeris(const GalileoEphemerisResponse& ephRpt, + GalileoEphemerisResponse& halEph) { + + /** Keep count of number of OTA based ephemeris to be reported to LCA */ + uint16_t numEph = 0; + uint16_t maxNumEph = std::min(ephRpt.numOfEphemeris, + (uint16_t)GNSS_EPHEMERIS_LIST_MAX_SIZE_V02); + + for (uint16_t idx = 0; idx < maxNumEph; idx++) { + if (isEphNetworkBased(ephRpt.galEphemerisData[idx].commonEphemerisData)) { + continue; + } + halEph.galEphemerisData[numEph] = ephRpt.galEphemerisData[idx]; + numEph++; + } + + halEph.numOfEphemeris = numEph; + +} + +void GnssAdapter::convertGloEphemeris(const GlonassEphemerisResponse& ephRpt, + GlonassEphemerisResponse& halEph) { + + /** Keep count of number of OTA based ephemeris to be reported to LCA */ + uint16_t numEph = 0; + uint16_t maxNumEph = std::min(ephRpt.numOfEphemeris, + (uint16_t)GNSS_EPHEMERIS_LIST_MAX_SIZE_V02); + + for (uint16_t idx = 0; idx < maxNumEph; idx++) { + if (GNSS_EPH_ACTION_UPDATE_SRC_NETWORK_V02 == ephRpt.gloEphemerisData[idx].updateAction || + GNSS_EPH_ACTION_DELETE_SRC_NETWORK_V02 == + ephRpt.gloEphemerisData[idx].updateAction) { + continue; + } + halEph.gloEphemerisData[numEph] = ephRpt.gloEphemerisData[idx]; + numEph++; + } + + halEph.numOfEphemeris = numEph; + +} + +void GnssAdapter::convertBdsEphemeris(const BdsEphemerisResponse& ephRpt, + BdsEphemerisResponse& halEph) { + + /** Keep count of number of OTA based ephemeris to be reported to LCA */ + uint16_t numEph = 0; + uint16_t maxNumEph = std::min(ephRpt.numOfEphemeris, + (uint16_t)GNSS_EPHEMERIS_LIST_MAX_SIZE_V02); + + for (uint16_t idx = 0; idx < maxNumEph; idx++) { + if (isEphNetworkBased(ephRpt.bdsEphemerisData[idx].commonEphemerisData)) { + continue; + } + halEph.bdsEphemerisData[numEph] = ephRpt.bdsEphemerisData[idx]; + numEph++; + } + + halEph.numOfEphemeris = numEph; +} + +void GnssAdapter::convertQzssEphemeris(const QzssEphemerisResponse& ephRpt, + QzssEphemerisResponse& halEph) { + + /** Keep count of number of OTA based ephemeris to be reported to LCA */ + uint16_t numEph = 0; + uint16_t maxNumEph = std::min(ephRpt.numOfEphemeris, + (uint16_t)GNSS_EPHEMERIS_LIST_MAX_SIZE_V02); + + for (uint16_t idx = 0; idx < maxNumEph; idx++) { + if (isEphNetworkBased(ephRpt.qzssEphemerisData[idx].commonEphemerisData)) { + continue; + } + + halEph.qzssEphemerisData[numEph] = ephRpt.qzssEphemerisData[idx]; + numEph++; + } + + halEph.numOfEphemeris = numEph; +} +void GnssAdapter::convertNavicEphemeris(const NavicEphemerisResponse& ephRpt, + NavicEphemerisResponse& halEph) { + + /** Keep count of number of OTA based ephemeris to be reported to LCA */ + uint16_t numEph = 0; + uint16_t maxNumEph = std::min(ephRpt.numOfEphemeris, + (uint16_t)GNSS_EPHEMERIS_LIST_MAX_SIZE_V02); + + for (uint16_t idx = 0; idx < maxNumEph; idx++) { + if (isEphNetworkBased(ephRpt.navicEphemerisData[idx].commonEphemerisData)) { + continue; + } + halEph.navicEphemerisData[numEph] = ephRpt.navicEphemerisData[idx]; + numEph++; + } + + halEph.numOfEphemeris = numEph; +} + +void +GnssAdapter::convertEphReportInfo(const GnssSvEphemerisReport& svEphemeris, + GnssSvEphemerisReport& ephReport, bool& needToReportEph) { + + switch (svEphemeris.gnssConstellation) { + case GNSS_LOC_SV_SYSTEM_GPS: + ephReport.gnssConstellation = GNSS_LOC_SV_SYSTEM_GPS; + convertGpsEphemeris(svEphemeris.ephInfo.gpsEphemeris, + ephReport.ephInfo.gpsEphemeris); + if (!ephReport.ephInfo.gpsEphemeris.numOfEphemeris) { + needToReportEph = false; + } + break; + case GNSS_LOC_SV_SYSTEM_GALILEO: + ephReport.gnssConstellation = GNSS_LOC_SV_SYSTEM_GALILEO; + convertGalEphemeris(svEphemeris.ephInfo.galileoEphemeris, + ephReport.ephInfo.galileoEphemeris); + if (!ephReport.ephInfo.galileoEphemeris.numOfEphemeris) { + needToReportEph = false; + } + break; + case GNSS_LOC_SV_SYSTEM_GLONASS: + ephReport.gnssConstellation = GNSS_LOC_SV_SYSTEM_GLONASS; + convertGloEphemeris(svEphemeris.ephInfo.glonassEphemeris, + ephReport.ephInfo.glonassEphemeris); + if (!ephReport.ephInfo.glonassEphemeris.numOfEphemeris) { + needToReportEph = false; + } + break; + case GNSS_LOC_SV_SYSTEM_BDS: + ephReport.gnssConstellation = GNSS_LOC_SV_SYSTEM_BDS; + convertBdsEphemeris(svEphemeris.ephInfo.bdsEphemeris, + ephReport.ephInfo.bdsEphemeris); + if (!ephReport.ephInfo.bdsEphemeris.numOfEphemeris) { + needToReportEph = false; + } + break; + case GNSS_LOC_SV_SYSTEM_QZSS: + ephReport.gnssConstellation = GNSS_LOC_SV_SYSTEM_QZSS; + convertQzssEphemeris(svEphemeris.ephInfo.qzssEphemeris, + ephReport.ephInfo.qzssEphemeris); + if (!ephReport.ephInfo.qzssEphemeris.numOfEphemeris) { + needToReportEph = false; + } + break; + case GNSS_LOC_SV_SYSTEM_NAVIC: + ephReport.gnssConstellation = GNSS_LOC_SV_SYSTEM_NAVIC; + convertNavicEphemeris(svEphemeris.ephInfo.navicEphemeris, + ephReport.ephInfo.navicEphemeris); + if (!ephReport.ephInfo.navicEphemeris.numOfEphemeris) { + needToReportEph = false; + } + break; + default: + LOC_LOGe(" Unknown System for Ephemeris Data "); + needToReportEph = false; + break; + } + + if (needToReportEph && svEphemeris.isSystemTimeValid) { + ephReport.isSystemTimeValid = 1; + ephReport.systemTime = svEphemeris.systemTime; + } +} + +void +GnssAdapter::reportSvEphemerisData (const GnssSvEphemerisReport& svEphemeris) { + GnssSvEphemerisReport svEphRpt = {}; + bool needToReportEph = true; + convertEphReportInfo(svEphemeris, svEphRpt, needToReportEph); + /** If all the Eph Data is network based, we do not report it to LCA */ + if (needToReportEph) { + for (auto it=mClientData.begin(); it != mClientData.end(); ++it) { + if (nullptr != it->second.svEphemerisCb) { + it->second.svEphemerisCb(svEphRpt); + } + } + } +} + void GnssAdapter::reportSvEphemerisEvent(GnssSvEphemerisReport & svEphemeris) { + + struct MsgReportSvEphemerisData : public LocMsg { + GnssAdapter& mAdapter; + GnssSvEphemerisReport mSvEphemerisData; + inline MsgReportSvEphemerisData(GnssAdapter& adapter, + const GnssSvEphemerisReport& svEphemerisData) : + LocMsg(), + mAdapter(adapter), + mSvEphemerisData(svEphemerisData) { + } + + inline virtual void proc() const { + mAdapter.reportSvEphemerisData(mSvEphemerisData); + } + }; + + sendMsg(new MsgReportSvEphemerisData(*this, svEphemeris)); mEngHubProxy->gnssReportSvEphemeris(svEphemeris); } diff --git a/gnss/GnssAdapter.h b/gnss/GnssAdapter.h index 1cc6dacd..8706c1f6 100644 --- a/gnss/GnssAdapter.h +++ b/gnss/GnssAdapter.h @@ -30,7 +30,7 @@ /* Changes from Qualcomm Innovation Center are provided under the following license: -Copyright (c) 2022-2023 Qualcomm Innovation Center, Inc. All rights reserved. +Copyright (c) 2022-2024 Qualcomm Innovation Center, Inc. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted (subject to the limitations in the @@ -390,6 +390,22 @@ class GnssAdapter : public LocAdapterBase { static uint16_t getNumSvUsed(uint64_t svUsedIdsMask, int totalSvCntInThisConstellation); + static bool isEphNetworkBased(const GnssEphCommon& commanEphRpt); + static void convertGpsEphemeris(const GpsEphemerisResponse& ephRpt, + GpsEphemerisResponse& halEph); + static void convertGalEphemeris(const GalileoEphemerisResponse& ephRpt, + GalileoEphemerisResponse& halEph); + static void convertGloEphemeris(const GlonassEphemerisResponse& ephRpt, + GlonassEphemerisResponse& halEph); + static void convertBdsEphemeris(const BdsEphemerisResponse& ephRpt, + BdsEphemerisResponse& halEph); + static void convertQzssEphemeris(const QzssEphemerisResponse& ephRpt, + QzssEphemerisResponse& halEph); + static void convertNavicEphemeris(const NavicEphemerisResponse& ephRpt, + NavicEphemerisResponse& halEph); + static void convertEphReportInfo(const GnssSvEphemerisReport& svEphemeris, + GnssSvEphemerisReport& ephInfo, bool& needToReportEph); + /* ======== UTILITIES ================================================================== */ inline void initOdcpi(const odcpiRequestCallback& callback, OdcpiPrioritytype priority, @@ -746,6 +762,7 @@ class GnssAdapter : public LocAdapterBase { mControlCallbacks.nfwStatusCb(notification); } } + void reportSvEphemerisData (const GnssSvEphemerisReport& svEphemeris); inline bool getE911State(GnssNiType niType) { if (NULL != mControlCallbacks.isInEmergencyStatusCb) { return mControlCallbacks.isInEmergencyStatusCb(); diff --git a/location/LocationAPI.cpp b/location/LocationAPI.cpp index 0545ea69..e6783aed 100644 --- a/location/LocationAPI.cpp +++ b/location/LocationAPI.cpp @@ -28,7 +28,7 @@ /* Changes from Qualcomm Innovation Center are provided under the following license: -Copyright (c) 2022, 2023 Qualcomm Innovation Center, Inc. All rights reserved. +Copyright (c) 2022, 2023-2024 Qualcomm Innovation Center, Inc. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted (subject to the limitations in the @@ -199,7 +199,8 @@ static bool isGnssClient(LocationCallbacks& locationCallbacks) locationCallbacks.gnssNHzMeasurementsCb != nullptr || locationCallbacks.locationSystemInfoCb != nullptr || locationCallbacks.gnssDcReportCb != nullptr || - locationCallbacks.gnssSignalTypesCb != nullptr); + locationCallbacks.gnssSignalTypesCb != nullptr || + locationCallbacks.svEphemerisCb != nullptr); } static bool isBatchingClient(LocationCallbacks& locationCallbacks) diff --git a/location/LocationAPIClientBase.h b/location/LocationAPIClientBase.h index ea7ed2b3..760837a8 100644 --- a/location/LocationAPIClientBase.h +++ b/location/LocationAPIClientBase.h @@ -28,7 +28,7 @@ /* Changes from Qualcomm Innovation Center are provided under the following license: -Copyright (c) 2022 Qualcomm Innovation Center, Inc. All rights reserved. +Copyright (c) 2022, 2024 Qualcomm Innovation Center, Inc. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted (subject to the limitations in the @@ -322,6 +322,9 @@ class LocationAPIClientBase { inline virtual void onLocationSystemInfoCb(LocationSystemInfo /*locationSystemInfo*/) {} + inline virtual void onGnssSvEphemerisCb ( + const GnssSvEphemerisReport& /*gnssEphemerisNotification*/) {} + protected: virtual ~LocationAPIClientBase(); diff --git a/location/LocationDataTypes.h b/location/LocationDataTypes.h index ab95d499..8010e8ed 100644 --- a/location/LocationDataTypes.h +++ b/location/LocationDataTypes.h @@ -95,7 +95,10 @@ IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #define UNKNOWN_GPS_WEEK_NUM (65535) #define REAL_TIME_ESTIMATOR_TIME_UNC_THRESHOLD_MSEC (20.0f) -typedef enum { +/** Maximum number of satellites in an ephemeris report. */ +#define GNSS_EPHEMERIS_LIST_MAX_SIZE_V02 32 + +enum LocationError { LOCATION_ERROR_SUCCESS = 0, LOCATION_ERROR_GENERAL_FAILURE, LOCATION_ERROR_CALLBACK_MISSING, @@ -109,11 +112,11 @@ typedef enum { LOCATION_ERROR_SYSTEM_NOT_READY, LOCATION_ERROR_EXCLUSIVE_SESSION_IN_PROGRESS, LOCATION_ERROR_TZ_LOCKED, -} LocationError; +}; // Flags to indicate which values are valid in a Location typedef uint16_t LocationFlagsMask; -typedef enum { +enum LocationFlagsBits { LOCATION_HAS_LAT_LONG_BIT = (1<<0), // location has valid latitude and longitude LOCATION_HAS_ALTITUDE_BIT = (1<<1), // location has valid altitude LOCATION_HAS_SPEED_BIT = (1<<2), // location has valid speed @@ -130,11 +133,11 @@ typedef enum { LOCATION_HAS_TIME_UNC_BIT = (1<<13), // location has timeUncMs LOCATION_HAS_GPTP_TIME_BIT = (1<<14), // location has valid GPTP time LOCATION_HAS_GPTP_TIME_UNC_BIT = (1<<15), // location has valid GPTP time Uncertainity -} LocationFlagsBits; +}; typedef uint16_t LocationTechnologyMask; // mask indicating location calculations including... -typedef enum { +enum LocationTechnologyBits{ LOCATION_TECHNOLOGY_GNSS_BIT = (1<<0), // using GNSS LOCATION_TECHNOLOGY_CELL_BIT = (1<<1), // using Cell LOCATION_TECHNOLOGY_WIFI_BIT = (1<<2), // using WiFi @@ -150,25 +153,25 @@ typedef enum { LOCATION_TECHNOLOGY_HYBRID_ALE_BIT = (1<<12), // HYBRID using ALE POS LOCATION_TECHNOLOGY_PDR_BIT = (1<<13), // PED mode LOCATION_TECHNOLOGY_PROPAGATED_BIT = (1<<14), //using cached measures -} LocationTechnologyBits; +}; typedef uint32_t LocationSpoofMask; -typedef enum { +enum LocationSpoofBits { LOCATION_POSTION_SPOOFED = (1<<0), // location position spoofed LOCATION_TIME_SPOOFED = (1<<1), // location time spoofed LOCATION_NAVIGATION_DATA_SPOOFED = (1<<2), // location navigation data spoofed -} LocationSpoofBits; +}; -typedef enum { +enum LocationReliability { LOCATION_RELIABILITY_NOT_SET = 0, LOCATION_RELIABILITY_VERY_LOW, LOCATION_RELIABILITY_LOW, LOCATION_RELIABILITY_MEDIUM, LOCATION_RELIABILITY_HIGH, -} LocationReliability; +}; typedef uint32_t GnssLocationNavSolutionMask; -typedef enum { +enum GnssLocationNavSolutionBits { // SBAS ionospheric correction is used LOCATION_SBAS_CORRECTION_IONO_BIT = (1<<0), // SBAS fast correction is used @@ -187,10 +190,10 @@ typedef enum { LOCATION_NAV_CORRECTION_RTK_FIXED_BIT = (1<<7), // Position report is computed with only SBAS corrected SVs. LOCATION_NAV_CORRECTION_ONLY_SBAS_CORRECTED_SV_USED_BIT = (1<<8) -} GnssLocationNavSolutionBits; +}; typedef uint32_t GnssLocationPosDataMask; -typedef enum { +enum GnssLocationPosDataBits { LOCATION_NAV_DATA_HAS_LONG_ACCEL_BIT = (1<<0), // Navigation data has Forward Acceleration LOCATION_NAV_DATA_HAS_LAT_ACCEL_BIT = (1<<1), // Navigation data has Sideward Acceleration LOCATION_NAV_DATA_HAS_VERT_ACCEL_BIT = (1<<2), // Navigation data has Vertical Acceleration @@ -206,10 +209,10 @@ typedef enum { LOCATION_NAV_DATA_HAS_YAW_RATE_UNC_BIT = (1<<8), // Navigation data has Body pitch uncertainty LOCATION_NAV_DATA_HAS_PITCH_UNC_BIT = (1<<9) -} GnssLocationPosDataBits; +}; typedef uint32_t GnssLocationPosDataMaskExt; -typedef enum { +enum GnssLocationPosDataBitsExt { // Navigation data has pitch rate LOCATION_NAV_DATA_HAS_PITCH_RATE_BIT = (1<<0), // Navigation data has body pitch rate uncertainty @@ -226,7 +229,7 @@ typedef enum { LOCATION_NAV_DATA_HAS_YAW_BIT = (1<<6), // Navigation data has body roll uncertainty LOCATION_NAV_DATA_HAS_YAW_UNC_BIT = (1<<7) -} GnssLocationPosDataBitsExt; +}; typedef uint64_t GnssLocationInfoFlagMask; #define LDT_GNSS_LOCATION_INFO_ALTITUDE_MEAN_SEA_LEVEL_BIT (1<<0) // altitude mean sea level @@ -271,32 +274,32 @@ typedef uint64_t GnssLocationInfoFlagMask; #define LDT_GNSS_LOCATION_INFO_PROTECT_VERTICAL_BIT (1ULL<<36) // vertical protection level #define LDT_GNSS_LOCATION_INFO_DGNSS_STATION_ID_BIT (1ULL<<37) // dgnss station id -typedef enum { +enum GeofenceBreachType { GEOFENCE_BREACH_ENTER = 0, GEOFENCE_BREACH_EXIT, GEOFENCE_BREACH_DWELL_IN, GEOFENCE_BREACH_DWELL_OUT, GEOFENCE_BREACH_UNKNOWN, -} GeofenceBreachType; +}; typedef uint16_t GeofenceBreachTypeMask; -typedef enum { +enum GeofenceBreachTypeBits { GEOFENCE_BREACH_ENTER_BIT = (1<<0), GEOFENCE_BREACH_EXIT_BIT = (1<<1), GEOFENCE_BREACH_DWELL_IN_BIT = (1<<2), GEOFENCE_BREACH_DWELL_OUT_BIT = (1<<3), -} GeofenceBreachTypeBits; +}; -typedef enum { +enum GeofenceStatusAvailable { GEOFENCE_STATUS_AVAILABILE_NO = 0, GEOFENCE_STATUS_AVAILABILE_YES, -} GeofenceStatusAvailable; +}; -typedef enum { +enum GeofenceConfidence { GEOFENCE_CONFIDENCE_LOW = 1, GEOFENCE_CONFIDENCE_MEDIUM, GEOFENCE_CONFIDENCE_HIGH, -} GeofenceConfidence; +}; // Set of masks for Modem and QWES capabilities. typedef uint64_t LocationCapabilitiesMask; @@ -395,7 +398,7 @@ typedef uint64_t LocationCapabilitiesMask; #define LOCATION_CAPABILITIES_QWES_GNSS_NHZ (1ULL<<37) typedef uint8_t LocationQwesFeatureType; -typedef enum { +enum LocationQwesFeatureTypes { // Modem supports Carrier Phase for Precise Positioning // Measurement Engine (PPME). LOCATION_QWES_FEATURE_TYPE_CARRIER_PHASE = 1, @@ -454,19 +457,19 @@ typedef enum { LOCATION_QWES_FEATURE_STATUS_GNSS_NHZ = 20, // Max value LOCATION_QWES_FEATURE_TYPE_MAX = 21 -} LocationQwesFeatureTypes; +}; typedef uint64_t LocationHwCapabilitiesMask; -typedef enum { +enum LocationHwCapabilitiesBits { // This indicates wifi HW has RSSI capability. LOCATION_WIFI_CAPABILITY_RSSI = (1<<0), // This indicates wifi HW has RTT capability. LOCATION_WIFI_CAPABILITY_RTT = (1<<1) -} LocationHwCapabilitiesBits; +}; -typedef enum { +enum LocationTechnologyType { LOCATION_TECHNOLOGY_TYPE_GNSS = 0, -} LocationTechnologyType; +}; // Configures how GPS is locked when GPS is disabled (through GnssDisable) /* @@ -508,26 +511,26 @@ enum { typedef uint32_t GnssConfigGpsLock; // SUPL version -typedef enum { +enum GnssConfigSuplVersion { GNSS_CONFIG_SUPL_VERSION_1_0_0 = 1, GNSS_CONFIG_SUPL_VERSION_2_0_0, GNSS_CONFIG_SUPL_VERSION_2_0_2, GNSS_CONFIG_SUPL_VERSION_2_0_4, -} GnssConfigSuplVersion; +}; // LTE Positioning Profile typedef uint16_t GnssConfigLppProfileMask; -typedef enum { +enum GnssConfigLppProfileBits { GNSS_CONFIG_LPP_PROFILE_RRLP_ON_LTE = 0, // RRLP on LTE (Default) GNSS_CONFIG_LPP_PROFILE_USER_PLANE_BIT = (1<<0), // LPP User Plane (UP) on LTE GNSS_CONFIG_LPP_PROFILE_CONTROL_PLANE_BIT = (1<<1), // LPP_Control_Plane (CP) GNSS_CONFIG_LPP_PROFILE_USER_PLANE_OVER_NR5G_SA_BIT = (1<<2), // LPP User Plane (UP) on LTE GNSS_CONFIG_LPP_PROFILE_CONTROL_PLANE_OVER_NR5G_SA_BIT = (1<<3), // LPP_Control_Plane (CP) -} GnssConfigLppProfileBits; +}; // Technology for LPPe Control Plane typedef uint16_t GnssConfigLppeControlPlaneMask; -typedef enum { +enum GnssConfigLppeControlPlaneBits { GNSS_CONFIG_LPPE_CONTROL_PLANE_DBH_BIT = (1<<0), // DBH GNSS_CONFIG_LPPE_CONTROL_PLANE_WLAN_AP_MEASUREMENTS_BIT = (1<<1), // WLAN_AP_MEASUREMENTS GNSS_CONFIG_LPPE_CONTROL_PLANE_SRN_AP_MEASUREMENTS_BIT = (1<<2), @@ -536,11 +539,11 @@ typedef enum { // SENSOR_BARO_MEASUREMENTS GNSS_CONFIG_LPPE_CONTROL_PLANE_NON_E911_BIT = (1<<4), // NON_E911 GNSS_CONFIG_LPPE_CONTROL_PLANE_CIV_ADDRESS_BIT = (1<<5), // CIV_ADDRESS -} GnssConfigLppeControlPlaneBits; +}; // Technology for LPPe User Plane typedef uint16_t GnssConfigLppeUserPlaneMask; -typedef enum { +enum GnssConfigLppeUserPlaneBits { GNSS_CONFIG_LPPE_USER_PLANE_DBH_BIT = (1<<0), // DBH GNSS_CONFIG_LPPE_USER_PLANE_WLAN_AP_MEASUREMENTS_BIT = (1<<1), // WLAN_AP_MEASUREMENTS GNSS_CONFIG_LPPE_USER_PLANE_SRN_AP_MEASUREMENTS_BIT = (1<<2), @@ -549,35 +552,35 @@ typedef enum { // SENSOR_BARO_MEASUREMENTS GNSS_CONFIG_LPPE_USER_PLANE_NON_E911_BIT = (1<<4), // NON_E911 GNSS_CONFIG_LPPE_USER_PLANE_CIV_ADDRESS_BIT = (1<<5), // CIV_ADDRESS -} GnssConfigLppeUserPlaneBits; +}; // Positioning Protocol on A-GLONASS system typedef uint16_t GnssConfigAGlonassPositionProtocolMask; -typedef enum { +enum GnssConfigAGlonassPositionProtocolBits { GNSS_CONFIG_RRC_CONTROL_PLANE_BIT = (1<<0), // RRC Control Plane GNSS_CONFIG_RRLP_USER_PLANE_BIT = (1<<1), // RRLP User Plane GNSS_CONFIG_LLP_USER_PLANE_BIT = (1<<2), // LPP User Plane GNSS_CONFIG_LLP_CONTROL_PLANE_BIT = (1<<3), // LPP Control Plane -} GnssConfigAGlonassPositionProtocolBits; +}; -typedef enum { +enum GnssConfigEmergencyPdnForEmergencySupl { GNSS_CONFIG_EMERGENCY_PDN_FOR_EMERGENCY_SUPL_NO = 0, GNSS_CONFIG_EMERGENCY_PDN_FOR_EMERGENCY_SUPL_YES, -} GnssConfigEmergencyPdnForEmergencySupl; +}; -typedef enum { +enum GnssConfigSuplEmergencyServices { GNSS_CONFIG_SUPL_EMERGENCY_SERVICES_NO = 0, GNSS_CONFIG_SUPL_EMERGENCY_SERVICES_YES, -} GnssConfigSuplEmergencyServices; +}; typedef uint16_t GnssConfigSuplModeMask; -typedef enum { +enum GnssConfigSuplModeBits { GNSS_CONFIG_SUPL_MODE_MSB_BIT = (1<<0), GNSS_CONFIG_SUPL_MODE_MSA_BIT = (1<<1), -} GnssConfigSuplModeBits; +}; typedef uint32_t GnssConfigFlagsMask; -typedef enum { +enum GnssConfigFlagsBits { GNSS_CONFIG_FLAGS_GPS_LOCK_VALID_BIT = (1<<0), GNSS_CONFIG_FLAGS_SUPL_VERSION_VALID_BIT = (1<<1), GNSS_CONFIG_FLAGS_SET_ASSISTANCE_DATA_VALID_BIT = (1<<2), @@ -595,37 +598,37 @@ typedef enum { GNSS_CONFIG_FLAGS_MIN_SV_ELEVATION_BIT = (1<<14), GNSS_CONFIG_FLAGS_CONSTELLATION_SECONDARY_BAND_BIT = (1<<15), GNSS_CONFIG_FLAGS_XTRA_STATUS_BIT = (1<<16), -} GnssConfigFlagsBits; +}; -typedef enum { +enum GnssNiEncodingType { GNSS_NI_ENCODING_TYPE_NONE = 0, GNSS_NI_ENCODING_TYPE_GSM_DEFAULT, GNSS_NI_ENCODING_TYPE_UTF8, GNSS_NI_ENCODING_TYPE_UCS2, -} GnssNiEncodingType; +}; -typedef enum { +enum GnssNiType { GNSS_NI_TYPE_VOICE = 0, GNSS_NI_TYPE_SUPL, GNSS_NI_TYPE_CONTROL_PLANE, GNSS_NI_TYPE_EMERGENCY_SUPL -} GnssNiType; +}; typedef uint16_t GnssNiOptionsMask; -typedef enum { +enum GnssNiOptionsBits { GNSS_NI_OPTIONS_NOTIFICATION_BIT = (1<<0), GNSS_NI_OPTIONS_VERIFICATION_BIT = (1<<1), GNSS_NI_OPTIONS_PRIVACY_OVERRIDE_BIT = (1<<2), -} GnssNiOptionsBits; +}; -typedef enum { +enum GnssNiResponse { GNSS_NI_RESPONSE_ACCEPT = 1, GNSS_NI_RESPONSE_DENY, GNSS_NI_RESPONSE_NO_RESPONSE, GNSS_NI_RESPONSE_IGNORE, -} GnssNiResponse; +}; -typedef enum { +enum GnssSvType { GNSS_SV_TYPE_UNKNOWN = 0, GNSS_SV_TYPE_GPS, GNSS_SV_TYPE_SBAS, @@ -634,30 +637,30 @@ typedef enum { GNSS_SV_TYPE_BEIDOU, GNSS_SV_TYPE_GALILEO, GNSS_SV_TYPE_NAVIC, -} GnssSvType; +}; -typedef enum { +enum GnssEphemerisType { GNSS_EPH_TYPE_UNKNOWN = 0, GNSS_EPH_TYPE_EPHEMERIS, GNSS_EPH_TYPE_ALMANAC, -} GnssEphemerisType; +}; -typedef enum { +enum GnssEphemerisSource { GNSS_EPH_SOURCE_UNKNOWN = 0, GNSS_EPH_SOURCE_DEMODULATED, GNSS_EPH_SOURCE_SUPL_PROVIDED, GNSS_EPH_SOURCE_OTHER_SERVER_PROVIDED, GNSS_EPH_SOURCE_LOCAL, -} GnssEphemerisSource; +}; -typedef enum { +enum GnssEphemerisHealth { GNSS_EPH_HEALTH_UNKNOWN = 0, GNSS_EPH_HEALTH_GOOD, GNSS_EPH_HEALTH_BAD, -} GnssEphemerisHealth; +}; typedef uint16_t GnssSvOptionsMask; -typedef enum { +enum GnssSvOptionsBits { GNSS_SV_OPTIONS_HAS_EPHEMER_BIT = (1<<0), GNSS_SV_OPTIONS_HAS_ALMANAC_BIT = (1<<1), // Bit indicates whether this SV is used in SPE fix. @@ -667,43 +670,43 @@ typedef enum { GNSS_SV_OPTIONS_HAS_BASEBAND_CARRIER_TO_NOISE_BIT = (1<<5), GNSS_SV_OPTIONS_HAS_ELEVATION_BIT = (1<<6), GNSS_SV_OPTIONS_HAS_AZIMUTH_BIT = (1<<7), -} GnssSvOptionsBits; +}; -typedef enum { +enum GnssAssistanceType { GNSS_ASSISTANCE_TYPE_SUPL = 0, GNSS_ASSISTANCE_TYPE_C2K, GNSS_ASSISTANCE_TYPE_SUPL_EIMS, GNSS_ASSISTANCE_TYPE_SUPL_IMS, -} GnssAssistanceType; +}; -typedef enum { +enum GnssSuplMode { GNSS_SUPL_MODE_STANDALONE = 0, GNSS_SUPL_MODE_MSB, GNSS_SUPL_MODE_MSA, -} GnssSuplMode; +}; -typedef enum { +enum BatchingMode { BATCHING_MODE_ROUTINE = 0, // positions are reported when batched positions memory is full BATCHING_MODE_TRIP, // positions are reported when a certain distance is covered BATCHING_MODE_NO_AUTO_REPORT // no report of positions automatically, instead queried on demand -} BatchingMode; +}; -typedef enum { +enum BatchingStatus { BATCHING_STATUS_TRIP_COMPLETED = 0, BATCHING_STATUS_POSITION_AVAILABE, BATCHING_STATUS_POSITION_UNAVAILABLE -} BatchingStatus; +}; typedef uint16_t GnssMeasurementsAdrStateMask; -typedef enum { +enum GnssMeasurementsAdrStateBits { GNSS_MEASUREMENTS_ACCUMULATED_DELTA_RANGE_STATE_UNKNOWN = 0, GNSS_MEASUREMENTS_ACCUMULATED_DELTA_RANGE_STATE_VALID_BIT = (1<<0), GNSS_MEASUREMENTS_ACCUMULATED_DELTA_RANGE_STATE_RESET_BIT = (1<<1), GNSS_MEASUREMENTS_ACCUMULATED_DELTA_RANGE_STATE_CYCLE_SLIP_BIT = (1<<2), GNSS_MEASUREMENTS_ACCUMULATED_DELTA_RANGE_STATE_HALF_CYCLE_RESOLVED_BIT = (1<<3), -} GnssMeasurementsAdrStateBits; +}; -typedef enum { +enum GnssMeasurementsCodeType { GNSS_MEASUREMENTS_CODE_TYPE_A = 0, GNSS_MEASUREMENTS_CODE_TYPE_B = 1, GNSS_MEASUREMENTS_CODE_TYPE_C = 2, @@ -719,10 +722,10 @@ typedef enum { GNSS_MEASUREMENTS_CODE_TYPE_Z = 12, GNSS_MEASUREMENTS_CODE_TYPE_N = 13, GNSS_MEASUREMENTS_CODE_TYPE_OTHER = 255, -} GnssMeasurementsCodeType; +}; typedef uint32_t GnssMeasurementsDataFlagsMask; -typedef enum { +enum GnssMeasurementsDataFlagsBits { GNSS_MEASUREMENTS_DATA_SV_ID_BIT = (1<<0), GNSS_MEASUREMENTS_DATA_SV_TYPE_BIT = (1<<1), GNSS_MEASUREMENTS_DATA_STATE_BIT = (1<<2), @@ -751,10 +754,10 @@ typedef enum { GNSS_MEASUREMENTS_DATA_GNSS_SIGNAL_TYPE_BIT = (1<<25), GNSS_MEASUREMENTS_DATA_GLO_FREQUENCY_BIT = (1<<26), GNSS_MEASUREMENTS_DATA_BASEBAND_CARRIER_TO_NOISE_BIT = (1<<27), -} GnssMeasurementsDataFlagsBits; +}; typedef uint32_t GnssMeasurementsStateMask; -typedef enum { +enum GnssMeasurementsStateBits { GNSS_MEASUREMENTS_STATE_UNKNOWN_BIT = 0, GNSS_MEASUREMENTS_STATE_CODE_LOCK_BIT = (1<<0), GNSS_MEASUREMENTS_STATE_BIT_SYNC_BIT = (1<<1), @@ -773,25 +776,25 @@ typedef enum { GNSS_MEASUREMENTS_STATE_TOW_KNOWN_BIT = (1<<14), GNSS_MEASUREMENTS_STATE_GLO_TOD_KNOWN_BIT = (1<<15), GNSS_MEASUREMENTS_STATE_2ND_CODE_LOCK_BIT = (1<<16), -} GnssMeasurementsStateBits; +}; typedef uint16_t GnssSingleSatCorrectionMask; -typedef enum { +enum GnssSingleSatCorrectionBits { GNSS_MEAS_CORR_UNKNOWN_BIT = 0, GNSS_MEAS_CORR_HAS_SAT_IS_LOS_PROBABILITY_BIT = (1 << 0), GNSS_MEAS_CORR_HAS_EXCESS_PATH_LENGTH_BIT = (1 << 1), GNSS_MEAS_CORR_HAS_EXCESS_PATH_LENGTH_UNC_BIT = (1 << 2), GNSS_MEAS_CORR_HAS_REFLECTING_PLANE_BIT = (1 << 3), -} GnssSingleSatCorrectionBits; +}; -typedef enum { +enum GnssMeasurementsMultipathIndicator { GNSS_MEASUREMENTS_MULTIPATH_INDICATOR_UNKNOWN = 0, GNSS_MEASUREMENTS_MULTIPATH_INDICATOR_PRESENT, GNSS_MEASUREMENTS_MULTIPATH_INDICATOR_NOT_PRESENT, -} GnssMeasurementsMultipathIndicator; +}; typedef uint32_t GnssMeasurementsClockFlagsMask; -typedef enum { +enum GnssMeasurementsClockFlagsBits { GNSS_MEASUREMENTS_CLOCK_FLAGS_LEAP_SECOND_BIT = (1<<0), GNSS_MEASUREMENTS_CLOCK_FLAGS_TIME_BIT = (1<<1), GNSS_MEASUREMENTS_CLOCK_FLAGS_TIME_UNCERTAINTY_BIT = (1<<2), @@ -805,10 +808,10 @@ typedef enum { GNSS_MEASUREMENTS_CLOCK_FLAGS_ELAPSED_REAL_TIME_UNC_BIT = (1<<10), GNSS_MEASUREMENTS_CLOCK_FLAGS_ELAPSED_GPTP_TIME_BIT = (1<<11), GNSS_MEASUREMENTS_CLOCK_FLAGS_ELAPSED_GPTP_TIME_UNC_BIT = (1<<12), -} GnssMeasurementsClockFlagsBits; +}; typedef uint32_t GnssAidingDataSvMask; -typedef enum { +enum GnssAidingDataSvBits { GNSS_AIDING_DATA_SV_EPHEMERIS_BIT = (1<<0), // ephemeris GNSS_AIDING_DATA_SV_ALMANAC_BIT = (1<<1), // almanac GNSS_AIDING_DATA_SV_HEALTH_BIT = (1<<2), // health @@ -822,10 +825,10 @@ typedef enum { GNSS_AIDING_DATA_SV_TIME_BIT = (1<<10), // reset satellite time GNSS_AIDING_DATA_SV_MB_DATA = (1<<11), // delete multiband data GNSS_AIDING_DATA_SV_POLY_BIT = (1<<12), // poly -} GnssAidingDataSvBits; +}; typedef uint32_t GnssAidingDataSvTypeMask; -typedef enum { +enum GnssAidingDataSvTypeBits { GNSS_AIDING_DATA_SV_TYPE_GPS_BIT = (1<<0), GNSS_AIDING_DATA_SV_TYPE_GLONASS_BIT = (1<<1), GNSS_AIDING_DATA_SV_TYPE_QZSS_BIT = (1<<2), @@ -833,12 +836,12 @@ typedef enum { GNSS_AIDING_DATA_SV_TYPE_GALILEO_BIT = (1<<4), GNSS_AIDING_DATA_SV_TYPE_NAVIC_BIT = (1<<5), GNSS_AIDING_DATA_SV_TYPE_MAX = (1<<6), -} GnssAidingDataSvTypeBits; +}; #define GNSS_AIDING_DATA_SV_TYPE_MASK_ALL (GNSS_AIDING_DATA_SV_TYPE_MAX-1) /* Gnss constellation type mask */ typedef uint16_t GnssConstellationTypeMask; -typedef enum { +enum GnssConstellationTypeBits { GNSS_CONSTELLATION_TYPE_GPS_BIT = (1<<0), GNSS_CONSTELLATION_TYPE_GLONASS_BIT = (1<<1), GNSS_CONSTELLATION_TYPE_QZSS_BIT = (1<<2), @@ -846,7 +849,7 @@ typedef enum { GNSS_CONSTELLATION_TYPE_GALILEO_BIT = (1<<4), 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 |\ @@ -856,7 +859,7 @@ typedef enum { /** GNSS Signal Type and RF Band */ typedef uint32_t GnssSignalTypeMask; -typedef enum { +enum GnssSignalTypeBits { /** GPS L1CA Signal */ GNSS_SIGNAL_GPS_L1CA = (1<<0), /** GPS L1C Signal */ @@ -905,7 +908,7 @@ typedef enum { GNSS_SIGNAL_BEIDOU_B2BI = (1<<22), /** BEIDOU B2B_Q RF Band */ GNSS_SIGNAL_BEIDOU_B2BQ = (1<<23), -} GnssSignalTypeBits; +}; #define GNSS_SIGNAL_TYPE_MASK_ALL\ (GNSS_SIGNAL_GPS_L1CA | GNSS_SIGNAL_GPS_L1C | GNSS_SIGNAL_GPS_L2 |\ @@ -917,7 +920,7 @@ typedef enum { GNSS_SIGNAL_NAVIC_L5 | GNSS_SIGNAL_BEIDOU_B2AQ | GNSS_SIGNAL_BEIDOU_B2BI |\ GNSS_SIGNAL_BEIDOU_B2BQ) -typedef enum { +enum Gnss_LocSvSystemEnumType { GNSS_LOC_SV_SYSTEM_UNKNOWN = 0, /** unknown sv system. */ GNSS_LOC_SV_SYSTEM_MIN = 1, @@ -938,9 +941,9 @@ typedef enum { /**< NAVIC satellite. */ GNSS_LOC_SV_SYSTEM_MAX = 7, /**< Max enum of valid SV system. */ -} Gnss_LocSvSystemEnumType; +}; -typedef enum { +enum Gnss_LocSignalEnumType { GNSS_LOC_SIGNAL_TYPE_GPS_L1CA = 0, /**< GPS L1CA Signal */ GNSS_LOC_SIGNAL_TYPE_GPS_L1C = 1, /**< GPS L1C Signal */ GNSS_LOC_SIGNAL_TYPE_GPS_L2C_L = 2, /**< GPS L2C_L RF Band */ @@ -964,15 +967,15 @@ typedef enum { GNSS_LOC_SIGNAL_TYPE_BEIDOU_B2B_I = 20, /**< BeiDou B2B_I RF band (data) */ GNSS_LOC_SIGNAL_TYPE_BEIDOU_B2B_Q = 21, /**< BeiDou B2B_Q RF band (Pilot)*/ GNSS_LOC_MAX_NUMBER_OF_SIGNAL_TYPES = 22 /**< Maximum number of signal types */ -} Gnss_LocSignalEnumType; +}; typedef uint32_t PositioningEngineMask; -typedef enum { +enum PositioningEngineBits { STANDARD_POSITIONING_ENGINE = (1 << 0), DEAD_RECKONING_ENGINE = (1 << 1), PRECISE_POSITIONING_ENGINE = (1 << 2), VP_POSITIONING_ENGINE = (1 << 3) -} PositioningEngineBits; +}; #define POSITION_ENGINE_MASK_ALL \ (STANDARD_POSITIONING_ENGINE|DEAD_RECKONING_ENGINE| \ PRECISE_POSITIONING_ENGINE|VP_POSITIONING_ENGINE) @@ -998,25 +1001,25 @@ enum LocEngineRunState { }; typedef uint64_t GnssDataMask; -typedef enum { +enum GnssDataBits { // Jammer Indicator is available GNSS_LOC_DATA_JAMMER_IND_BIT = (1ULL << 0), // AGC is available GNSS_LOC_DATA_AGC_BIT = (1ULL << 1) -} GnssDataBits; +}; typedef uint32_t GnssSystemTimeStructTypeFlags; -typedef enum { +enum GnssSystemTimeTypeBits { GNSS_SYSTEM_TIME_WEEK_VALID = (1 << 0), GNSS_SYSTEM_TIME_WEEK_MS_VALID = (1 << 1), GNSS_SYSTEM_CLK_TIME_BIAS_VALID = (1 << 2), GNSS_SYSTEM_CLK_TIME_BIAS_UNC_VALID = (1 << 3), GNSS_SYSTEM_REF_FCOUNT_VALID = (1 << 4), GNSS_SYSTEM_NUM_CLOCK_RESETS_VALID = (1 << 5) -} GnssSystemTimeTypeBits; +}; typedef uint32_t GnssGloTimeStructTypeFlags; -typedef enum { +enum GnssGloTimeTypeBits { GNSS_CLO_DAYS_VALID = (1 << 0), GNSS_GLO_MSEC_VALID = (1 << 1), GNSS_GLO_CLK_TIME_BIAS_VALID = (1 << 2), @@ -1024,42 +1027,42 @@ typedef enum { GNSS_GLO_REF_FCOUNT_VALID = (1 << 4), GNSS_GLO_NUM_CLOCK_RESETS_VALID = (1 << 5), GNSS_GLO_FOUR_YEAR_VALID = (1 << 6) -} GnssGloTimeTypeBits; +}; -typedef struct { +struct GnssAidingDataSv { GnssAidingDataSvMask svMask; // bitwise OR of GnssAidingDataSvBits GnssAidingDataSvTypeMask svTypeMask; // bitwise OR of GnssAidingDataSvTypeBits -} GnssAidingDataSv; +}; typedef uint32_t GnssAidingDataCommonMask; -typedef enum { +enum GnssAidingDataCommonBits { GNSS_AIDING_DATA_COMMON_POSITION_BIT = (1<<0), // position estimate GNSS_AIDING_DATA_COMMON_TIME_BIT = (1<<1), // reset all clock values GNSS_AIDING_DATA_COMMON_UTC_BIT = (1<<2), // UTC estimate GNSS_AIDING_DATA_COMMON_RTI_BIT = (1<<3), // RTI GNSS_AIDING_DATA_COMMON_FREQ_BIAS_EST_BIT = (1<<4), // frequency bias estimate GNSS_AIDING_DATA_COMMON_CELLDB_BIT = (1<<5), // all celldb info -} GnssAidingDataCommonBits; +}; -typedef struct { +struct GnssAidingDataCommon { GnssAidingDataCommonMask mask; // bitwise OR of GnssAidingDataCommonBits -} GnssAidingDataCommon; +}; typedef uint32_t DrEngineAidingDataMask; -typedef enum { +enum DrEngineAidingDataBits { DR_ENGINE_AIDING_DATA_CALIBRATION_BIT = (1<<0), // Calibration data for DRE engine -} DrEngineAidingDataBits; +}; -typedef struct { +struct GnssAidingData { bool deleteAll; // if true, delete all aiding data and ignore other params GnssAidingDataSv sv; // SV specific aiding data GnssAidingDataCommon common; // common aiding data DrEngineAidingDataMask dreAidingDataMask;// aiding data mask for dr engine PositioningEngineMask posEngineMask; // engines to perform the delete operation on. -} GnssAidingData; +}; typedef uint32_t DrCalibrationStatusMask; -typedef enum { +enum DrCalibrationStatusBits { // Indicate that roll calibration is needed. Need to take more turns on level ground DR_ROLL_CALIBRATION_NEEDED = (1<<0), // Indicate that pitch calibration is needed. Need to take more turns on level ground @@ -1094,9 +1097,9 @@ typedef enum { DR_STATIC_CALIBRATION_MEDIUM = (1<<15), // Sufficient stationary events on level ground observed DR_STATIC_CALIBRATION_HIGH = (1<<16) -} DrCalibrationStatusBits; +}; -typedef enum { +enum LocationQualityType { /**< Position calculated by standard alone postion engine. */ LOCATION_STANDALONE_QUALITY_TYPE = 0, /**< Position calculated by using DGNSS technology. */ @@ -1105,10 +1108,10 @@ typedef enum { LOCATION_FLOAT_QUALITY_TYPE = 2, /**< Position accuracy in RTK or PPP fixed performance. */ LOCATION_FIXED_QUALITY_TYPE = 3, -} LocationQualityType; +}; -typedef struct { +struct Location { uint32_t size; // set to sizeof(Location) LocationFlagsMask flags; // bitwise OR of LocationFlagsBits to mark which params are valid uint64_t timestamp; // UTC timestamp for location fix, milliseconds since January 1, 1970 @@ -1138,16 +1141,16 @@ typedef struct { uint64_t elapsedgPTPTime; // GPTP time Unc uint64_t elapsedgPTPTimeUnc; -} Location; +}; -typedef enum { +enum LocReqEngineTypeMask { LOC_REQ_ENGINE_FUSED_BIT = (1<<0), LOC_REQ_ENGINE_SPE_BIT = (1<<1), LOC_REQ_ENGINE_PPE_BIT = (1<<2), LOC_REQ_ENGINE_VPE_BIT = (1<<3) -} LocReqEngineTypeMask; +}; -typedef enum { +enum LocOutputEngineType { LOC_OUTPUT_ENGINE_FUSED = 0, /** This is the GNSS fix from modem */ LOC_OUTPUT_ENGINE_SPE = 1, @@ -1155,13 +1158,13 @@ typedef enum { LOC_OUTPUT_ENGINE_PPE = 2, LOC_OUTPUT_ENGINE_VPE = 3, LOC_OUTPUT_ENGINE_COUNT, -} LocOutputEngineType; +}; -typedef enum { +enum FixQualityLevel { QUALITY_HIGH_ACCU_FIX_ONLY = 0, /* Only allow valid fix with high accuracy */ QUALITY_ANY_VALID_FIX, /* Allow fix with any accuracy, like intermediate fix */ QUALITY_ANY_OR_FAILED_FIX, /* Allow fix of any type, even failed fix */ -} FixQualityLevel; +}; struct LocationOptions { uint32_t size; // set to sizeof(LocationOptions) @@ -1181,19 +1184,19 @@ struct LocationOptions { qualityLevelAccepted(QUALITY_HIGH_ACCU_FIX_ONLY) {} }; -typedef enum { +enum GnssPowerMode { GNSS_POWER_MODE_M1 = 1, /* Improved Accuracy Mode */ GNSS_POWER_MODE_M2, /* Normal Mode */ GNSS_POWER_MODE_M3, /* Background Mode */ GNSS_POWER_MODE_M4, /* Background Mode */ GNSS_POWER_MODE_M5, /* Background Mode */ GNSS_POWER_MODE_DEFAULT = GNSS_POWER_MODE_M2 -} GnssPowerMode; +}; -typedef enum { +enum SpecialReqType { SPECIAL_REQ_INVALID = 0, SPECIAL_REQ_SHORT_CODE, /* Short code */ -} SpecialReqType; +}; struct TrackingOptions : LocationOptions { GnssPowerMode powerMode; /* Power Mode to be used for time based tracking @@ -1267,51 +1270,51 @@ struct BatchingOptions : LocationOptions { } }; -typedef struct { +struct BatchingStatusInfo { uint32_t size; BatchingStatus batchingStatus; -} BatchingStatusInfo; +}; -typedef struct { +struct GeofenceOption { uint32_t size; // set to sizeof(GeofenceOption) GeofenceBreachTypeMask breachTypeMask; // bitwise OR of GeofenceBreachTypeBits uint32_t responsiveness; // in milliseconds uint32_t dwellTime; // in seconds GeofenceConfidence confidence; // confidence of breach event -} GeofenceOption; +}; -typedef struct { +struct GeofenceInfo { uint32_t size; // set to sizeof(GeofenceInfo) double latitude; // in degrees double longitude; // in degrees double radius; // in meters -} GeofenceInfo; +}; -typedef struct { +struct GeofenceBreachNotification { uint32_t size; // set to sizeof(GeofenceBreachNotification) uint32_t count; // number of ids in array uint32_t* ids; // array of ids that have breached Location location; // location associated with breach GeofenceBreachType type; // type of breach uint64_t timestamp; // timestamp of breach -} GeofenceBreachNotification; +}; -typedef struct { +struct GeofenceStatusNotification { uint32_t size; // set to sizeof(GeofenceBreachNotification) GeofenceStatusAvailable available; // GEOFENCE_STATUS_AVAILABILE_NO/_YES LocationTechnologyType techType; // GNSS -} GeofenceStatusNotification; +}; -typedef struct { +struct GnssLocationSvUsedInPosition { uint64_t gpsSvUsedIdsMask; uint64_t gloSvUsedIdsMask; uint64_t galSvUsedIdsMask; uint64_t bdsSvUsedIdsMask; uint64_t qzssSvUsedIdsMask; uint64_t navicSvUsedIdsMask; -} GnssLocationSvUsedInPosition; +}; -typedef struct { +struct GnssMeasUsageInfo { /** GnssSignalType mask */ GnssSignalTypeMask gnssSignalType; /** Specifies GNSS Constellation Type */ @@ -1322,12 +1325,12 @@ typedef struct { * For GLONASS: When slot-number to SV ID mapping is unknown, set as 255. */ uint16_t gnssSvId; -} GnssMeasUsageInfo; +}; /** @struct Body Frame parameters */ -typedef struct { +struct GnssLocationPositionDynamics { GnssLocationPosDataMask bodyFrameDataMask; // Contains Body frame LocPosDataMask bits float longAccel; // Forward Acceleration in body frame (m/s2) float latAccel; // Sideward Acceleration in body frame (m/s2) @@ -1344,9 +1347,9 @@ typedef struct { // Confidence level is at 68% float pitchUnc; // Uncertainty of Body pitch // Confidence level is at 68% -} GnssLocationPositionDynamics; +}; -typedef struct { +struct GnssLocationPositionDynamicsExt { GnssLocationPosDataMaskExt bodyFrameDataMask; // Contains Ext Body frame LocPosDataMask bits float pitchRate; // Body pitch rate (Radians/second) float pitchRateUnc; // Uncertainty of pitch rate (Radians/second) @@ -1360,9 +1363,9 @@ typedef struct { float yaw; // Yaw of body frame. Clockwise positive (radian) float yawUnc; // Uncertainty of Yaw (radian) // Confidence level is at 68% -} GnssLocationPositionDynamicsExt; +}; -typedef struct { +struct GnssSystemTimeStructType { /** Validity mask for below fields */ GnssSystemTimeStructTypeFlags validityMask; /** Extended week number at reference tick. @@ -1413,9 +1416,9 @@ typedef struct { } return retVal; } -} GnssSystemTimeStructType; +}; -typedef struct { +struct GnssGloTimeStructType { /** GLONASS day number in four years. Refer to GLONASS ICD. Applicable only for GLONASS and shall be ignored for other constellations. If unknown shall be set to 65535 */ @@ -1445,7 +1448,7 @@ typedef struct { Applicable only for GLONASS and shall be ignored for other constellations. If unknown shall be set to 255 */ uint8_t gloFourYear; -} GnssGloTimeStructType; +}; typedef union { GnssSystemTimeStructType gpsSystemTime; @@ -1457,7 +1460,7 @@ typedef union { } SystemTimeStructUnion; /** Time applicability of PVT report */ -typedef struct { +struct GnssSystemTime { /** Specifies GNSS system time reported. Mandatory field */ Gnss_LocSvSystemEnumType gnssSystemTimeSrc; /** Reporting of GPS system time is recommended. @@ -1476,7 +1479,7 @@ typedef struct { return retVal; } -} GnssSystemTime; +}; typedef uint32_t DrSolutionStatusMask; #define VEHICLE_SENSOR_SPEED_INPUT_DETECTED (1<<0) @@ -1496,11 +1499,11 @@ typedef uint32_t DrSolutionStatusMask; #define DRE_WARNING_USER_DYNAMICS_INSUFFICIENT (1<<14) #define DRE_WARNING_FACTORY_DATA_INCONSISTENT (1<<15) -typedef struct { +struct LLAInfo { double latitude; // in degree double longitude; // in degree float altitude; // altitude wrt to ellipsoid -} LLAInfo; +}; enum loc_sess_status { LOC_SESS_SUCCESS, @@ -1508,7 +1511,7 @@ enum loc_sess_status { LOC_SESS_FAILURE }; -typedef struct { +struct GnssLocationInfoNotification { uint32_t size; // set to sizeof(GnssLocationInfo) Location location; // basic locaiton info, latitude, longitude, and etc GnssLocationInfoFlagMask flags; // bitwise OR of GnssLocationInfoBits for param validity @@ -1588,7 +1591,7 @@ typedef struct { // - Monitoring station -- 1000-2023 (Station ID biased by 1000). // - Other values reserved. uint16_t dgnssStationId[DGNSS_STATION_ID_MAX]; -} GnssLocationInfoNotification; +}; // Indicate the API that is called to generate the location report enum LocReportTriggerType { @@ -1614,7 +1617,7 @@ struct DiagLocationInfoExt { reportTriggerType(inReportTriggerType) {} }; -typedef struct { +struct GnssNiNotification { uint32_t size; // set to sizeof(GnssNiNotification) GnssNiType type; // type of NI (Voice, SUPL, Control Plane) GnssNiOptionsMask options; // bitwise OR of GnssNiOptionsBits @@ -1625,7 +1628,7 @@ typedef struct { char message[GNSS_NI_MESSAGE_ID_MAX]; // the message to show user GnssNiEncodingType messageEncoding; // the encoding type for message char extras[GNSS_NI_MESSAGE_ID_MAX]; -} GnssNiNotification; +}; // carrier frequency of the signal tracked #define GPS_L1CA_CARRIER_FREQUENCY (1575420000.0) @@ -1651,7 +1654,7 @@ typedef struct { #define SBAS_L1_CA_CARRIER_FREQUENCY (1575420000.0) #define NAVIC_L5_CARRIER_FREQUENCY (1176450000.0) -typedef struct { +struct GnssSv { uint32_t size; // set to sizeof(GnssSv) // Unique SV Identifier. // SV Range for supported constellation is specified as below: @@ -1672,7 +1675,7 @@ typedef struct { GnssSignalTypeMask gnssSignalTypeMask; // Specifies GNSS signal type double basebandCarrierToNoiseDbHz; // baseband signal strength uint16_t gloFrequency; // GLONASS Frequency channel number -} GnssSv; +}; struct GnssConfigSetAssistanceServer { uint32_t size; // set to sizeof(GnssConfigSetAssistanceServer) @@ -1692,41 +1695,41 @@ struct GnssConfigSetAssistanceServer { }; typedef uint32_t GnssSatellitePvtFlagsMask; -typedef enum { +enum GnssSatellitePvtFlagsBits { GNSS_SATELLITE_PVT_POSITION_VELOCITY_CLOCK_INFO_BIT = (1 << 0), GNSS_SATELLITE_PVT_IONO_BIT = (1 << 1), GNSS_SATELLITE_PVT_TROPO_BIT = (1 << 2), -} GnssSatellitePvtFlagsBits; +}; -typedef struct { +struct GnssSatellitePositionEcef { double posXMeters; double posYMeters; double posZMeters; double ureMeters; -} GnssSatellitePositionEcef; +}; -typedef struct { +struct GnssSatelliteVelocityEcef { double velXMps; double velYMps; double velZMps; double ureRateMps; -} GnssSatelliteVelocityEcef; +}; -typedef struct { +struct GnssSatelliteClockInfo { double satHardwareCodeBiasMeters; double satTimeCorrectionMeters; double satClkDriftMps; -} GnssSatelliteClockInfo; +}; -typedef enum { +enum GnssEphemerisSourceExt { GNSS_EPHEMERIS_SOURCE_EXT_INVALID = 0, GNSS_EPHEMERIS_SOURCE_EXT_DEMODULATED, GNSS_EPHEMERIS_SOURCE_EXT_SERVER_NORMAL, GNSS_EPHEMERIS_SOURCE_EXT_SERVER_LONG_TERM, GNSS_EPHEMERIS_SOURCE_EXT_OTHER, -} GnssEphemerisSourceExt; +}; -typedef struct { +struct GnssSatellitePvt { GnssSatellitePvtFlagsMask flags; GnssSatellitePositionEcef satPosEcef; GnssSatelliteVelocityEcef satVelEcef; @@ -1738,9 +1741,9 @@ typedef struct { int64_t TOE; int IODE; GnssEphemerisSourceExt ephemerisSource; -} GnssSatellitePvt; +}; -typedef struct { +struct GnssMeasurementsData { // set to sizeof(GnssMeasurementsData) uint32_t size; // bitwise OR of GnssMeasurementsDataFlagsBits @@ -1783,24 +1786,24 @@ typedef struct { int16_t gloFrequency; uint8_t cycleSlipCount; GnssSatellitePvt satellitePvt; -} GnssMeasurementsData; +}; -typedef struct { +struct GnssMeasurementsSignalType { GnssSvType svType; double carrierFrequencyHz; GnssMeasurementsCodeType codeType; char otherCodeTypeName[GNSS_MAX_NAME_LENGTH]; -} GnssMeasurementsSignalType; +}; -typedef struct { +struct GnssReflectingPlane { uint32_t size; // set to sizeof(GnssReflectingPlane) double latitudeDegrees; double longitudeDegrees; double altitudeMeters; double azimuthDegrees; -} GnssReflectingPlane; +}; -typedef struct { +struct GnssSingleSatCorrection { uint32_t size; // set to sizeof(GnssSingleSatCorrection) GnssSingleSatCorrectionMask flags; GnssSvType svType; @@ -1810,9 +1813,9 @@ typedef struct { float excessPathLengthMeters; float excessPathLengthUncertaintyMeters; GnssReflectingPlane reflectingPlane; -} GnssSingleSatCorrection; +}; -typedef struct { +struct GnssMeasurementCorrections { uint32_t size; // set to sizeof(GnssMeasurementCorrections) double latitudeDegrees; double longitudeDegrees; @@ -1824,9 +1827,9 @@ typedef struct { bool hasEnvironmentBearing; float environmentBearingDegrees; float environmentBearingUncertaintyDegrees; -} GnssMeasurementCorrections; +}; -typedef struct { +struct GnssMeasurementsClock { uint32_t size; // set to sizeof(GnssMeasurementsClock) GnssMeasurementsClockFlagsMask flags; // bitwise OR of GnssMeasurementsClockFlagsBits int16_t leapSecond; @@ -1843,38 +1846,38 @@ typedef struct { uint64_t elapsedRealTimeUnc; // in ns uint64_t elapsedgPTPTime; // in ns uint64_t elapsedgPTPTimeUnc; // in ns -} GnssMeasurementsClock; +}; -typedef struct { +struct GnssSvNotification { uint32_t size; // set to sizeof(GnssSvNotification) uint32_t count; // number of SVs in the GnssSv array bool gnssSignalTypeMaskValid; GnssSv gnssSvs[GNSS_SV_MAX]; // information on a number of SVs -} GnssSvNotification; +}; -typedef struct { +struct GnssNmeaNotification { uint32_t size; // set to sizeof(GnssNmeaNotification) uint64_t timestamp; // timestamp LocOutputEngineType locOutputEngType; // engine type const char* nmea; // nmea text uint32_t length; // length of the nmea text bool isSvNmea; // is NMEA from SV report or not -} GnssNmeaNotification; +}; -typedef struct { +struct GnssDataNotification { uint32_t size; // set to sizeof(GnssDataNotification) GnssDataMask gnssDataMask[GNSS_LOC_MAX_NUMBER_OF_SIGNAL_TYPES]; // bitwise OR of GnssDataBits double jammerInd[GNSS_LOC_MAX_NUMBER_OF_SIGNAL_TYPES]; // Jammer Indication double agc[GNSS_LOC_MAX_NUMBER_OF_SIGNAL_TYPES]; // Automatic gain control -} GnssDataNotification; +}; -typedef struct { +struct GnssMeasurementsAgc { double agcLevelDb; GnssSvType svType; double carrierFrequencyHz; -} GnssMeasurementsAgc; +}; -typedef struct { +struct GnssMeasurementsNotification { uint32_t size; // set to sizeof(GnssMeasurementsNotification) bool isNhz; // NHz indicator uint32_t count; // number of items in GnssMeasurements array @@ -1883,14 +1886,14 @@ typedef struct { bool isFullTracking; uint32_t agcCount; // number of items in GnssMeasurementsAgc array GnssMeasurementsAgc gnssAgc[GNSS_BANDS_MAX]; -} GnssMeasurementsNotification; +}; -typedef struct { +struct GnssCapabNotification { uint32_t size; // set to sizeof(GnssCapabilitiesNotification) uint32_t count; // number of SVs in the gnssSignalType array GnssMeasurementsSignalType gnssSignalType[GNSS_LOC_MAX_NUMBER_OF_SIGNAL_TYPES]; GnssSignalTypeMask gnssSupportedSignals; // GNSS Supported Signals -} GnssCapabNotification; +}; typedef uint32_t GnssSvId; @@ -1994,14 +1997,14 @@ struct GnssConfigRobustLocation { /* Mask indicating enabled or disabled constellations and secondary frequency.*/ typedef uint64_t GnssSvTypesMask; -typedef enum { +enum GnssSvTypesMaskBits { 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), GNSS_SV_TYPES_MASK_GPS_BIT = (1<<5), -} GnssSvTypesMaskBits; +}; #define GNSS_SV_TYPES_MASK_ALL \ (GNSS_SV_TYPES_MASK_GPS_BIT|GNSS_SV_TYPES_MASK_GLO_BIT|GNSS_SV_TYPES_MASK_BDS_BIT|\ GNSS_SV_TYPES_MASK_QZSS_BIT|GNSS_SV_TYPES_MASK_GAL_BIT|GNSS_SV_TYPES_MASK_NAVIC_BIT) @@ -2078,7 +2081,7 @@ struct XtraStatus { } }; -struct GnssConfig{ +struct GnssConfig { uint32_t size; // set to sizeof(GnssConfig) GnssConfigFlagsMask flags; // bitwise OR of GnssConfigFlagsBits to mark which params are valid GnssConfigGpsLock gpsLock; @@ -2123,7 +2126,7 @@ struct GnssConfig{ } }; -typedef struct { +struct GnssDebugLocation { uint32_t size; // set to sizeof bool mValid; Location mLocation; @@ -2131,17 +2134,17 @@ typedef struct { double speedAccuracyMetersPerSecond; double bearingAccuracyDegrees; timespec mUtcReported; -} GnssDebugLocation; +}; -typedef struct { +struct GnssDebugTime { uint32_t size; // set to sizeof bool mValid; int64_t timeEstimate; float timeUncertaintyNs; float frequencyUncertaintyNsPerSec; -} GnssDebugTime; +}; -typedef struct { +struct GnssDebugSatelliteInfo { // set to sizeof uint32_t size; // Unique SV Identifier @@ -2155,17 +2158,17 @@ typedef struct { float ephemerisAgeSeconds; bool serverPredictionIsAvailable; float serverPredictionAgeSeconds; -} GnssDebugSatelliteInfo; +}; -typedef struct { +struct GnssDebugReport { uint32_t size; // set to sizeof GnssDebugLocation mLocation; GnssDebugTime mTime; std::vector mSatelliteInfo; -} GnssDebugReport; +}; typedef uint32_t LeapSecondSysInfoMask; -typedef enum { +enum LeapSecondSysInfoDataBits { // current leap second info is available. This info will only // be available if the leap second change info is not available. // @@ -2180,7 +2183,7 @@ typedef enum { // 2: this leap second change event has already happened and next // leap second change event has not yet been scheduled. LEAP_SECOND_SYS_INFO_LEAP_SECOND_CHANGE_BIT = (1ULL << 1), -} LeapSecondSysInfoDataBits; +}; struct LeapSecondChangeInfo { // GPS timestamp that corrresponds to the last known @@ -2453,7 +2456,7 @@ struct OdcpiRequestInfo { }; /** AGPS type */ -typedef enum { +enum AGpsType { AGPS_TYPE_INVALID = - 1, AGPS_TYPE_ANY = 0, AGPS_TYPE_SUPL, @@ -2461,31 +2464,31 @@ typedef enum { AGPS_TYPE_WWAN_ANY, AGPS_TYPE_WIFI, AGPS_TYPE_SUPL_ES -} AGpsType; +}; -typedef enum { +enum SubId { DEFAULT_SUB = 0, PRIMARY_SUB = 1, SECONDARY_SUB = 2, TERTIARY_SUB = 3 -} SubId; +}; typedef uint32_t AGpsTypeMask; -typedef enum { +enum AGpsTypeBits { AGPS_ATL_TYPE_SUPL = 1 << 0, AGPS_ATL_TYPE_SUPL_ES = 1 << 1, AGPS_ATL_TYPE_WWAN = 1 << 2, -} AGpsTypeBits; +}; -typedef enum { +enum AgpsCbPriority { AGPS_CB_PRIORITY_NONE = 0, AGPS_CB_PRIORITY_LOW = 1, AGPS_CB_PRIORITY_MED = 2, AGPS_CB_PRIORITY_HIGH = 3, -} AgpsCbPriority; +}; /** AGPS status event values. */ -typedef enum { +enum AGpsStatusValue { AGPS_REQUEST_AGPS_DATA_CONN = 1, /** GPS releases the AGPS data connection. */ AGPS_RELEASE_AGPS_DATA_CONN, @@ -2495,10 +2498,10 @@ typedef enum { AGPS_DATA_CONN_DONE, /** AGPS data connection failed */ AGPS_DATA_CONN_FAILED -} AGpsStatusValue; +}; typedef uint32_t ApnTypeMask; -typedef enum { +enum ApnTypeBits { /**< Denotes APN type for Default/Internet traffic */ APN_TYPE_DEFAULT_BIT = (1 << 0), /**< Denotes APN type for IP Multimedia Subsystem */ @@ -2519,7 +2522,7 @@ typedef enum { APN_TYPE_IA_BIT = (1 << 8), /**< Denotes APN type for emergency */ APN_TYPE_EMERGENCY_BIT = (1 << 9) -} ApnTypeBits; +}; /* @@ -2536,7 +2539,7 @@ struct AGnssExtStatusIpV4 { SubId subId; }; -typedef struct { +struct GnssCoordinate { uint32_t size; // set to sizeof double x; double xUncertainty; @@ -2544,10 +2547,10 @@ typedef struct { double yUncertainty; double z; double zUncertainty; -} GnssCoordinate; +}; -typedef struct { +struct GnssAntennaInformation{ uint32_t size; // set to sizeof double carrierFrequencyMHz; GnssCoordinate phaseCenterOffsetCoordinateMillimeters; @@ -2555,9 +2558,9 @@ typedef struct { std::vector> phaseCenterVariationCorrectionUncertaintyMillimeters; std::vector> signalGainCorrectionDbi; std::vector> signalGainCorrectionUncertaintyDbi; -} GnssAntennaInformation; +}; -typedef struct { +struct GnssNtripConnectionParams { uint32_t size; // set to sizeof bool requiresNmeaLocation; std::string hostNameOrIp; // null terminated string @@ -2567,7 +2570,7 @@ typedef struct { uint32_t port; bool useSSL; uint32_t nmeaUpdateInterval; // unit: second -} GnssNtripConnectionParams; +}; /* * Represents the the Nfw Notification structure @@ -2575,15 +2578,15 @@ typedef struct { #define GNSS_MAX_NFW_APP_STRING_LEN 64 #define GNSS_MAX_NFW_STRING_LEN 20 -typedef enum { +enum GnssNfwProtocolStack { GNSS_NFW_CTRL_PLANE = 0, GNSS_NFW_SUPL = 1, GNSS_NFW_IMS = 10, GNSS_NFW_SIM = 11, GNSS_NFW_OTHER_PROTOCOL_STACK = 100 -} GnssNfwProtocolStack; +}; -typedef enum { +enum GnssNfwRequestor { GNSS_NFW_CARRIER = 0, GNSS_NFW_OEM = 10, GNSS_NFW_MODEM_CHIPSET_VENDOR = 11, @@ -2591,15 +2594,15 @@ typedef enum { GNSS_NFW_OTHER_CHIPSET_VENDOR = 13, GNSS_NFW_AUTOMOBILE_CLIENT = 20, GNSS_NFW_OTHER_REQUESTOR = 100 -} GnssNfwRequestor; +}; -typedef enum { +enum GnssNfwResponseType { GNSS_NFW_REJECTED = 0, GNSS_NFW_ACCEPTED_NO_LOCATION_PROVIDED = 1, GNSS_NFW_ACCEPTED_LOCATION_PROVIDED = 2, -} GnssNfwResponseType; +}; -typedef struct { +struct GnssNfwNotification { char proxyAppPackageName[GNSS_MAX_NFW_APP_STRING_LEN]; GnssNfwProtocolStack protocolStack; char otherProtocolStackName[GNSS_MAX_NFW_STRING_LEN]; @@ -2608,14 +2611,14 @@ typedef struct { GnssNfwResponseType responseType; bool inEmergencyMode; bool isCachedLocation; -} GnssNfwNotification; +}; typedef uint16_t GnssMeasurementCorrectionsCapabilitiesMask; -typedef enum { +enum GnssMeasurementCorrectionsCapabilities { GNSS_MEAS_CORR_LOS_SATS = 1 << 0, GNSS_MEAS_CORR_EXCESS_PATH_LENGTH = 1 << 1, GNSS_MEAS_CORR_REFLECTING_PLANE = 1 << 2, -} GnssMeasurementCorrectionsCapabilities; +}; /* Specify the valid fields in GnssEnergyConsumedInfo. */ enum GnssEnergyConsumedInfoMask { @@ -2740,6 +2743,489 @@ enum XtraStatusUpdateType { XTRA_STATUS_UPDATE_UPON_STATUS_CHANGE = 4, }; +/**************** EPH REPORT *************/ +/** Specifies the Source of ephemeris and action to be performed on + * receipt of the ephemeris (Update/Delete) Action shall be + * performed on GnssEphSource specified */ +enum GnssEphAction { + /** gnssEnergyConsumedCallback; -typedef struct { +/** Callback to receive OTA ephemeris data reported by MODEM */ +typedef std::function gnssSvEphemerisCallback; + +struct LocationCallbacks { uint32_t size; // set to sizeof(LocationCallbacks) capabilitiesCallback capabilitiesCb; // mandatory responseCallback responseCb; // mandatory @@ -2955,9 +3446,10 @@ typedef struct { gnssDcReportCallback gnssDcReportCb; // optional gnssNmeaCallback engineNmeaCb; // optional gnssSignalTypesCallback gnssSignalTypesCb; // optional -} LocationCallbacks; + gnssSvEphemerisCallback svEphemerisCb; // optional +}; -typedef struct { +struct LocationControlCallbacks { size_t size; // set to sizeof(LocationControlCallbacks) responseCallback responseCb; // mandatory collectiveResponseCallback collectiveResponseCb; // mandatory @@ -2968,10 +3460,10 @@ typedef struct { nfwStatusCallback nfwStatusCb; // optional isInEmergencySessionCallback isInEmergencyStatusCb; // optional xtraStatusCallback xtraStatusCb; // optional -} LocationControlCallbacks; +}; -typedef struct { +struct GnssLatencyInfo { uint64_t meQtimer1; uint64_t meQtimer2; uint64_t meQtimer3; @@ -2987,9 +3479,9 @@ typedef struct { uint64_t hlosQtimer3; uint64_t hlosQtimer4; uint64_t hlosQtimer5; -} GnssLatencyInfo; +}; -typedef struct { +struct GnssCivicAddress { uint32_t size; std::string adminArea; std::string countryCode; @@ -3009,7 +3501,7 @@ typedef struct { std::string thoroughfare; std::string subThoroughfare; std::string url; -} GnssCivicAddress; +}; enum PowerStateType { POWER_STATE_UNKNOWN = 0, @@ -3025,26 +3517,26 @@ typedef uint64_t NetworkHandle; #define MAX_NETWORK_HANDLES 10 /* enum OSNMA New Public Key Type (NPKT) */ -typedef enum { +enum mgpOsnmaNpktEnumTypeVal { MGP_OSNMA_NPKT_RESERVED0 = 0, /* reserved 0 */ MGP_OSNMA_NPKT_ECDSA_P_256 = 1, /* 1: ECDSA P-256, key length shall be 264 */ MGP_OSNMA_NPKT_RESERVED2 = 2, /* reserved 2 */ MGP_OSNMA_NPKT_ECDSA_P_521 = 3, /* 3: ECDSA P-521, key length shall be 536 */ MGP_OSNMA_NPKT_ALERT = 4 /* OSNMA Alert Message (OAM) */ -} mgpOsnmaNpktEnumTypeVal; +}; typedef uint8_t mgpOsnmaNpktEnumType; /* Tree Node structure */ -typedef struct { +struct mgpOsnmaTreeNodeT { uint8_t uj; /* the height of the node in the Merkle Tree */ uint8_t ui; /* the position of the node in the Merkle Tree level */ uint16_t wLengthInBits; /* the length in bits of the hash in the x_ji element; shall be 256 */ uint8_t uHash[32]; /* Hash of Merkle tree nodes */ -} mgpOsnmaTreeNodeT; +}; /* public key structure */ -typedef struct { +struct mgpOsnmaPublicKeyT { uint8_t uFlag; /* 1: valid, 0: invalid */ mgpOsnmaNpktEnumType eNpkt; /* Public key type */ uint8_t uNpkId; /* public key ID */ @@ -3053,35 +3545,35 @@ typedef struct { mgpOsnmaTreeNodeT zNodes[4]; /* required Merkle tree nodes at level 0, 1, 2, 3 zNodes[0] is at level 0; zNodes[3] is at level 3 */ -} mgpOsnmaPublicKeyT; +}; /* Hash Function (HF) */ -typedef enum { +enum mgpOsnmaHfEnumTypeVal { MGP_OSNMA_HF_SHA_256 = 0, /* 0: SHA-256 */ MGP_OSNMA_HF_RESERVED1 = 1, /* 1: reserved */ MGP_OSNMA_HF_SHA3_256 = 2, /* 2: SHA3-256 */ MGP_OSNMA_HF_RESERVED3 = 3, /* 3: reserved */ -} mgpOsnmaHfEnumTypeVal; +}; typedef uint8_t mgpOsnmaHfEnumType; /* Merkle Tree Nodes */ -typedef struct { +struct mgpOsnmaMerkleTreeT { uint8_t uFlag; /* 1: valid; 0: invalid */ mgpOsnmaHfEnumType eHfType; mgpOsnmaTreeNodeT zRootNode; /* Root Node */ -} mgpOsnmaMerkleTreeT; +}; -typedef struct { +struct mgpOsnmaPublicKeyAndMerkleTreeStruct { mgpOsnmaPublicKeyT zPublicKey; /* public key */ mgpOsnmaMerkleTreeT zMerkleTree; /* Merkle Tree Nodes */ -} mgpOsnmaPublicKeyAndMerkleTreeStruct; +}; -enum { +enum ModemGnssQesdkFeatureBits { MODEM_QESDK_FEATURE_CARRIER_PHASE = (1<<0), MODEM_QESDK_FEATURE_SV_POLYNOMIALS = (1<<1), MODEM_QESDK_FEATURE_DGNSS = (1<<2), MODEM_QESDK_FEATURE_ROBUST_LOCATION = (1<<3) -} ModemGnssQesdkFeatureBits; +}; typedef uint64_t ModemGnssQesdkFeatureMask; @@ -3101,10 +3593,10 @@ typedef std::function QDgnssModem3GppAvailCb; -enum { +enum OdcpiCallbackTypeMaskBits { NON_EMERGENCY_ODCPI = (1<<0), EMERGENCY_ODCPI = (1<<1) -} OdcpiCallbackTypeMaskBits; +}; typedef uint16_t OdcpiCallbackTypeMask; diff --git a/utils/gps_extended_c.h b/utils/gps_extended_c.h index 2eb251b3..3d83d854 100644 --- a/utils/gps_extended_c.h +++ b/utils/gps_extended_c.h @@ -27,7 +27,7 @@ */ /* -Copyright (c) 2022-2023 Qualcomm Innovation Center, Inc. All rights reserved. +Copyright (c) 2022-2024 Qualcomm Innovation Center, Inc. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted (subject to the limitations in the @@ -131,9 +131,6 @@ typedef uint32_t LocSvInfoSource; /* TBM Threshold for tracking in background power mode : in millis */ #define TRACKING_TBM_THRESHOLD_MILLIS 480000 -/** Maximum number of satellites in an ephemeris report. */ -#define GNSS_EPHEMERIS_LIST_MAX_SIZE_V02 32 - typedef uint32_t LocPosTechMask; #define LOC_POS_TECH_MASK_DEFAULT ((LocPosTechMask)0x00000000) #define LOC_POS_TECH_MASK_SATELLITE ((LocPosTechMask)0x00000001) @@ -1682,466 +1679,6 @@ typedef struct { double polyClockBias[GNSS_SV_POLY_CLKBIAS_COEFF_SIZE_MAX]; } GnssSvPolynomial; -typedef enum { - GNSS_EPH_ACTION_UPDATE_SRC_UNKNOWN_V02 = 0, /**