| /* Copyright (c) 2017 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 |
| * met: |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * * Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following |
| * disclaimer in the documentation and/or other materials provided |
| * with the distribution. |
| * * Neither the name of The Linux Foundation nor the names of its |
| * contributors may be used to endorse or promote products derived |
| * from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED |
| * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
| * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT |
| * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS |
| * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR |
| * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, |
| * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE |
| * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN |
| * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #ifndef LOCATION_H |
| #define LOCATION_H |
| |
| #include <vector> |
| #include <stdint.h> |
| #include <functional> |
| |
| #define GNSS_NI_REQUESTOR_MAX 256 |
| #define GNSS_NI_MESSAGE_ID_MAX 2048 |
| #define GNSS_SV_MAX 64 |
| #define GNSS_MEASUREMENTS_MAX 64 |
| #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) |
| |
| typedef enum { |
| LOCATION_ERROR_SUCCESS = 0, |
| LOCATION_ERROR_GENERAL_FAILURE, |
| LOCATION_ERROR_CALLBACK_MISSING, |
| LOCATION_ERROR_INVALID_PARAMETER, |
| LOCATION_ERROR_ID_EXISTS, |
| LOCATION_ERROR_ID_UNKNOWN, |
| LOCATION_ERROR_ALREADY_STARTED, |
| LOCATION_ERROR_GEOFENCES_AT_MAX, |
| LOCATION_ERROR_NOT_SUPPORTED |
| } LocationError; |
| |
| // Flags to indicate which values are valid in a Location |
| typedef uint16_t LocationFlagsMask; |
| typedef enum { |
| 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 |
| LOCATION_HAS_BEARING_BIT = (1<<3), // location has valid bearing |
| LOCATION_HAS_ACCURACY_BIT = (1<<4), // location has valid accuracy |
| LOCATION_HAS_VERTICAL_ACCURACY_BIT = (1<<5), // location has valid vertical accuracy |
| LOCATION_HAS_SPEED_ACCURACY_BIT = (1<<6), // location has valid speed accuracy |
| LOCATION_HAS_BEARING_ACCURACY_BIT = (1<<7), // location has valid bearing accuracy |
| } LocationFlagsBits; |
| |
| typedef uint16_t LocationTechnologyMask; |
| typedef enum { |
| LOCATION_TECHNOLOGY_GNSS_BIT = (1<<0), // location was calculated using GNSS |
| LOCATION_TECHNOLOGY_CELL_BIT = (1<<1), // location was calculated using Cell |
| LOCATION_TECHNOLOGY_WIFI_BIT = (1<<2), // location was calculated using WiFi |
| LOCATION_TECHNOLOGY_SENSORS_BIT = (1<<3), // location was calculated using Sensors |
| } LocationTechnologyBits; |
| |
| typedef enum { |
| LOCATION_RELIABILITY_NOT_SET = 0, |
| LOCATION_RELIABILITY_VERY_LOW, |
| LOCATION_RELIABILITY_LOW, |
| LOCATION_RELIABILITY_MEDIUM, |
| LOCATION_RELIABILITY_HIGH, |
| } LocationReliability; |
| |
| typedef uint32_t GnssLocationInfoFlagMask; |
| typedef enum { |
| GNSS_LOCATION_INFO_ALTITUDE_MEAN_SEA_LEVEL_BIT = (1<<0), // valid altitude mean sea level |
| GNSS_LOCATION_INFO_DOP_BIT = (1<<1), // valid pdop, hdop, and vdop |
| GNSS_LOCATION_INFO_MAGNETIC_DEVIATION_BIT = (1<<2), // valid magnetic deviation |
| GNSS_LOCATION_INFO_HOR_RELIABILITY_BIT = (1<<3), // valid horizontal reliability |
| GNSS_LOCATION_INFO_VER_RELIABILITY_BIT = (1<<4), // valid vertical reliability |
| 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 |
| } GnssLocationInfoFlagBits; |
| |
| typedef enum { |
| 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 { |
| 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 { |
| GEOFENCE_STATUS_AVAILABILE_NO = 0, |
| GEOFENCE_STATUS_AVAILABILE_YES, |
| } GeofenceStatusAvailable; |
| |
| typedef uint32_t LocationCapabilitiesMask; |
| typedef enum { |
| // supports startTracking API with minInterval param |
| LOCATION_CAPABILITIES_TIME_BASED_TRACKING_BIT = (1<<0), |
| // supports startBatching API with minInterval param |
| LOCATION_CAPABILITIES_TIME_BASED_BATCHING_BIT = (1<<1), |
| // supports startTracking API with minDistance param |
| LOCATION_CAPABILITIES_DISTANCE_BASED_TRACKING_BIT = (1<<2), |
| // supports startBatching API with minDistance param |
| LOCATION_CAPABILITIES_DISTANCE_BASED_BATCHING_BIT = (1<<3), |
| // supports addGeofences API |
| LOCATION_CAPABILITIES_GEOFENCE_BIT = (1<<4), |
| // supports GnssMeasurementsCallback |
| LOCATION_CAPABILITIES_GNSS_MEASUREMENTS_BIT = (1<<5), |
| // supports startTracking/startBatching API with LocationOptions.mode of MSB (Ms Based) |
| LOCATION_CAPABILITIES_GNSS_MSB_BIT = (1<<6), |
| // supports startTracking/startBatching API with LocationOptions.mode of MSA (MS Assisted) |
| LOCATION_CAPABILITIES_GNSS_MSA_BIT = (1<<7), |
| } LocationCapabilitiesBits; |
| |
| typedef enum { |
| LOCATION_TECHNOLOGY_TYPE_GNSS = 0, |
| } LocationTechnologyType; |
| |
| // Configures how GPS is locked when GPS is disabled (through GnssDisable) |
| typedef enum { |
| GNSS_CONFIG_GPS_LOCK_NONE = 0, // gps is not locked when GPS is disabled (GnssDisable) |
| GNSS_CONFIG_GPS_LOCK_MO, // gps mobile originated (MO) is locked when GPS is disabled |
| GNSS_CONFIG_GPS_LOCK_NI, // gps network initiated (NI) is locked when GPS is disabled |
| GNSS_CONFIG_GPS_LOCK_MO_AND_NI,// gps MO and NI is locked when GPS is disabled |
| } GnssConfigGpsLock; |
| |
| // SUPL version |
| typedef enum { |
| GNSS_CONFIG_SUPL_VERSION_1_0_0 = 1, |
| GNSS_CONFIG_SUPL_VERSION_2_0_0, |
| GNSS_CONFIG_SUPL_VERSION_2_0_2, |
| } GnssConfigSuplVersion; |
| |
| // LTE Positioning Profile |
| typedef enum { |
| GNSS_CONFIG_LPP_PROFILE_RRLP_ON_LTE = 0, // RRLP on LTE (Default) |
| GNSS_CONFIG_LPP_PROFILE_USER_PLANE, // LPP User Plane (UP) on LTE |
| GNSS_CONFIG_LPP_PROFILE_CONTROL_PLANE, // LPP_Control_Plane (CP) |
| GNSS_CONFIG_LPP_PROFILE_USER_PLANE_AND_CONTROL_PLANE, // Both LPP UP and CP |
| } GnssConfigLppProfile; |
| |
| // Technology for LPPe Control Plane |
| typedef uint16_t GnssConfigLppeControlPlaneMask; |
| typedef enum { |
| GNSS_CONFIG_LPPE_CONTROL_PLANE_DBH_BIT = (1<<0), // DBH |
| GNSS_CONFIG_LPPE_CONTROL_PLANE_WLAN_AP_MEASUREMENTS_BIT = (1<<1), // WLAN_AP_MEASUREMENTS |
| } GnssConfigLppeControlPlaneBits; |
| |
| // Technology for LPPe User Plane |
| typedef uint16_t GnssConfigLppeUserPlaneMask; |
| typedef enum { |
| GNSS_CONFIG_LPPE_USER_PLANE_DBH_BIT = (1<<0), // DBH |
| GNSS_CONFIG_LPPE_USER_PLANE_WLAN_AP_MEASUREMENTS_BIT = (1<<1), // WLAN_AP_MEASUREMENTS |
| } GnssConfigLppeUserPlaneBits; |
| |
| // Positioning Protocol on A-GLONASS system |
| typedef uint16_t GnssConfigAGlonassPositionProtocolMask; |
| typedef enum { |
| 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 { |
| GNSS_CONFIG_EMERGENCY_PDN_FOR_EMERGENCY_SUPL_NO = 0, |
| GNSS_CONFIG_EMERGENCY_PDN_FOR_EMERGENCY_SUPL_YES, |
| } GnssConfigEmergencyPdnForEmergencySupl; |
| |
| typedef enum { |
| GNSS_CONFIG_SUPL_EMERGENCY_SERVICES_NO = 0, |
| GNSS_CONFIG_SUPL_EMERGENCY_SERVICES_YES, |
| } GnssConfigSuplEmergencyServices; |
| |
| typedef uint16_t GnssConfigSuplModeMask; |
| typedef enum { |
| GNSS_CONFIG_SUPL_MODE_MSB_BIT = (1<<0), |
| GNSS_CONFIG_SUPL_MODE_MSA_BIT = (1<<1), |
| } GnssConfigSuplModeBits; |
| |
| typedef uint32_t GnssConfigFlagsMask; |
| typedef enum { |
| 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), |
| GNSS_CONFIG_FLAGS_LPP_PROFILE_VALID_BIT = (1<<3), |
| GNSS_CONFIG_FLAGS_LPPE_CONTROL_PLANE_VALID_BIT = (1<<4), |
| GNSS_CONFIG_FLAGS_LPPE_USER_PLANE_VALID_BIT = (1<<5), |
| GNSS_CONFIG_FLAGS_AGLONASS_POSITION_PROTOCOL_VALID_BIT = (1<<6), |
| GNSS_CONFIG_FLAGS_EM_PDN_FOR_EM_SUPL_VALID_BIT = (1<<7), |
| GNSS_CONFIG_FLAGS_SUPL_EM_SERVICES_BIT = (1<<8), |
| GNSS_CONFIG_FLAGS_SUPL_MODE_BIT = (1<<9), |
| } GnssConfigFlagsBits; |
| |
| typedef enum { |
| 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 { |
| 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 { |
| 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 { |
| GNSS_NI_RESPONSE_ACCEPT = 1, |
| GNSS_NI_RESPONSE_DENY, |
| GNSS_NI_RESPONSE_NO_RESPONSE, |
| GNSS_NI_RESPONSE_IGNORE, |
| } GnssNiResponse; |
| |
| typedef enum { |
| GNSS_SV_TYPE_UNKNOWN = 0, |
| GNSS_SV_TYPE_GPS, |
| GNSS_SV_TYPE_SBAS, |
| GNSS_SV_TYPE_GLONASS, |
| GNSS_SV_TYPE_QZSS, |
| GNSS_SV_TYPE_BEIDOU, |
| GNSS_SV_TYPE_GALILEO, |
| } GnssSvType; |
| |
| typedef enum { |
| GNSS_EPH_TYPE_UNKNOWN = 0, |
| GNSS_EPH_TYPE_EPHEMERIS, |
| GNSS_EPH_TYPE_ALMANAC, |
| } GnssEphemerisType; |
| |
| typedef enum { |
| 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 { |
| GNSS_EPH_HEALTH_UNKNOWN = 0, |
| GNSS_EPH_HEALTH_GOOD, |
| GNSS_EPH_HEALTH_BAD, |
| } GnssEphemerisHealth; |
| |
| typedef uint16_t GnssSvOptionsMask; |
| typedef enum { |
| GNSS_SV_OPTIONS_HAS_EPHEMER_BIT = (1<<0), |
| GNSS_SV_OPTIONS_HAS_ALMANAC_BIT = (1<<1), |
| GNSS_SV_OPTIONS_USED_IN_FIX_BIT = (1<<2), |
| } GnssSvOptionsBits; |
| |
| typedef enum { |
| GNSS_ASSISTANCE_TYPE_SUPL = 0, |
| GNSS_ASSISTANCE_TYPE_C2K, |
| } GnssAssistanceType; |
| |
| typedef enum { |
| GNSS_SUPL_MODE_STANDALONE = 0, |
| GNSS_SUPL_MODE_MSB, |
| GNSS_SUPL_MODE_MSA, |
| } GnssSuplMode; |
| |
| typedef uint16_t GnssMeasurementsAdrStateMask; |
| typedef enum { |
| 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), |
| } GnssMeasurementsAdrStateBits; |
| |
| typedef uint32_t GnssMeasurementsDataFlagsMask; |
| typedef enum { |
| GNSS_MEASUREMENTS_DATA_SV_ID_BIT = (1<<0), |
| GNSS_MEASUREMENTS_DATA_SV_TYPE_BIT = (1<<1), |
| GNSS_MEASUREMENTS_DATA_STATE_BIT = (1<<2), |
| GNSS_MEASUREMENTS_DATA_RECEIVED_SV_TIME_BIT = (1<<3), |
| GNSS_MEASUREMENTS_DATA_RECEIVED_SV_TIME_UNCERTAINTY_BIT = (1<<4), |
| GNSS_MEASUREMENTS_DATA_CARRIER_TO_NOISE_BIT = (1<<5), |
| GNSS_MEASUREMENTS_DATA_PSEUDORANGE_RATE_BIT = (1<<6), |
| GNSS_MEASUREMENTS_DATA_PSEUDORANGE_RATE_UNCERTAINTY_BIT = (1<<7), |
| GNSS_MEASUREMENTS_DATA_ADR_STATE_BIT = (1<<8), |
| GNSS_MEASUREMENTS_DATA_ADR_BIT = (1<<9), |
| GNSS_MEASUREMENTS_DATA_ADR_UNCERTAINTY_BIT = (1<<10), |
| GNSS_MEASUREMENTS_DATA_CARRIER_FREQUENCY_BIT = (1<<11), |
| GNSS_MEASUREMENTS_DATA_CARRIER_CYCLES_BIT = (1<<12), |
| GNSS_MEASUREMENTS_DATA_CARRIER_PHASE_BIT = (1<<13), |
| GNSS_MEASUREMENTS_DATA_CARRIER_PHASE_UNCERTAINTY_BIT = (1<<14), |
| GNSS_MEASUREMENTS_DATA_MULTIPATH_INDICATOR_BIT = (1<<15), |
| GNSS_MEASUREMENTS_DATA_SIGNAL_TO_NOISE_RATIO_BIT = (1<<16), |
| GNSS_MEASUREMENTS_DATA_AUTOMATIC_GAIN_CONTROL_BIT = (1<<17), |
| } GnssMeasurementsDataFlagsBits; |
| |
| typedef uint32_t GnssMeasurementsStateMask; |
| typedef enum { |
| GNSS_MEASUREMENTS_STATE_UNKNOWN_BIT = 0, |
| GNSS_MEASUREMENTS_STATE_CODE_LOCK_BIT = (1<<0), |
| GNSS_MEASUREMENTS_STATE_BIT_SYNC_BIT = (1<<1), |
| GNSS_MEASUREMENTS_STATE_SUBFRAME_SYNC_BIT = (1<<2), |
| GNSS_MEASUREMENTS_STATE_TOW_DECODED_BIT = (1<<3), |
| GNSS_MEASUREMENTS_STATE_MSEC_AMBIGUOUS_BIT = (1<<4), |
| GNSS_MEASUREMENTS_STATE_SYMBOL_SYNC_BIT = (1<<5), |
| GNSS_MEASUREMENTS_STATE_GLO_STRING_SYNC_BIT = (1<<6), |
| GNSS_MEASUREMENTS_STATE_GLO_TOD_DECODED_BIT = (1<<7), |
| GNSS_MEASUREMENTS_STATE_BDS_D2_BIT_SYNC_BIT = (1<<8), |
| GNSS_MEASUREMENTS_STATE_BDS_D2_SUBFRAME_SYNC_BIT = (1<<9), |
| GNSS_MEASUREMENTS_STATE_GAL_E1BC_CODE_LOCK_BIT = (1<<10), |
| GNSS_MEASUREMENTS_STATE_GAL_E1C_2ND_CODE_LOCK_BIT = (1<<11), |
| GNSS_MEASUREMENTS_STATE_GAL_E1B_PAGE_SYNC_BIT = (1<<12), |
| GNSS_MEASUREMENTS_STATE_SBAS_SYNC_BIT = (1<<13), |
| } GnssMeasurementsStateBits; |
| |
| typedef enum { |
| GNSS_MEASUREMENTS_MULTIPATH_INDICATOR_UNKNOWN = 0, |
| GNSS_MEASUREMENTS_MULTIPATH_INDICATOR_PRESENT, |
| GNSS_MEASUREMENTS_MULTIPATH_INDICATOR_NOT_PRESENT, |
| } GnssMeasurementsMultipathIndicator; |
| |
| typedef uint32_t GnssMeasurementsClockFlagsMask; |
| typedef enum { |
| 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), |
| GNSS_MEASUREMENTS_CLOCK_FLAGS_FULL_BIAS_BIT = (1<<3), |
| GNSS_MEASUREMENTS_CLOCK_FLAGS_BIAS_BIT = (1<<4), |
| GNSS_MEASUREMENTS_CLOCK_FLAGS_BIAS_UNCERTAINTY_BIT = (1<<5), |
| GNSS_MEASUREMENTS_CLOCK_FLAGS_DRIFT_BIT = (1<<6), |
| GNSS_MEASUREMENTS_CLOCK_FLAGS_DRIFT_UNCERTAINTY_BIT = (1<<7), |
| GNSS_MEASUREMENTS_CLOCK_FLAGS_HW_CLOCK_DISCONTINUITY_COUNT_BIT = (1<<8), |
| } GnssMeasurementsClockFlagsBits; |
| |
| typedef uint32_t GnssAidingDataSvMask; |
| typedef enum { |
| 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 |
| GNSS_AIDING_DATA_SV_DIRECTION_BIT = (1<<3), // direction |
| GNSS_AIDING_DATA_SV_STEER_BIT = (1<<4), // steer |
| GNSS_AIDING_DATA_SV_ALMANAC_CORR_BIT = (1<<5), // almanac correction |
| GNSS_AIDING_DATA_SV_BLACKLIST_BIT = (1<<6), // blacklist SVs |
| GNSS_AIDING_DATA_SV_SA_DATA_BIT = (1<<7), // sensitivity assistance data |
| GNSS_AIDING_DATA_SV_NO_EXIST_BIT = (1<<8), // SV does not exist |
| GNSS_AIDING_DATA_SV_IONOSPHERE_BIT = (1<<9), // ionosphere correction |
| GNSS_AIDING_DATA_SV_TIME_BIT = (1<<10),// reset satellite time |
| } GnssAidingDataSvBits; |
| |
| typedef uint32_t GnssAidingDataSvTypeMask; |
| typedef enum { |
| 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), |
| GNSS_AIDING_DATA_SV_TYPE_BEIDOU_BIT = (1<<3), |
| GNSS_AIDING_DATA_SV_TYPE_GALILEO_BIT = (1<<4), |
| } GnssAidingDataSvTypeBits; |
| |
| typedef struct { |
| GnssAidingDataSvMask svMask; // bitwise OR of GnssAidingDataSvBits |
| GnssAidingDataSvTypeMask svTypeMask; // bitwise OR of GnssAidingDataSvTypeBits |
| } GnssAidingDataSv; |
| |
| typedef uint32_t GnssAidingDataCommonMask; |
| typedef enum { |
| 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 { |
| GnssAidingDataCommonMask mask; // bitwise OR of GnssAidingDataCommonBits |
| } GnssAidingDataCommon; |
| |
| typedef struct { |
| bool deleteAll; // if true, delete all aiding data and ignore other params |
| GnssAidingDataSv sv; // SV specific aiding data |
| GnssAidingDataCommon common; // common aiding data |
| } GnssAidingData; |
| |
| typedef struct { |
| size_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 |
| double latitude; // in degrees |
| double longitude; // in degrees |
| double altitude; // in meters above the WGS 84 reference ellipsoid |
| float speed; // in meters per second |
| float bearing; // in degrees; range [0, 360) |
| float accuracy; // in meters |
| float verticalAccuracy; // in meters |
| float speedAccuracy; // in meters/second |
| float bearingAccuracy; // in degrees (0 to 359.999) |
| LocationTechnologyMask techMask; |
| } Location; |
| |
| typedef struct { |
| size_t size; // set to sizeof(LocationOptions) |
| uint32_t minInterval; // in milliseconds |
| uint32_t minDistance; // in meters. if minDistance > 0, gnssSvCallback/gnssNmeaCallback/ |
| // gnssMeasurementsCallback may not be called |
| GnssSuplMode mode; // Standalone/MS-Based/MS-Assisted |
| } LocationOptions; |
| |
| typedef struct { |
| size_t size; // set to sizeof(GeofenceOption) |
| GeofenceBreachTypeMask breachTypeMask; // bitwise OR of GeofenceBreachTypeBits |
| uint32_t responsiveness; // in milliseconds |
| uint32_t dwellTime; // in seconds |
| } GeofenceOption; |
| |
| typedef struct { |
| size_t size; // set to sizeof(GeofenceInfo) |
| double latitude; // in degrees |
| double longitude; // in degrees |
| double radius; // in meters |
| } GeofenceInfo; |
| |
| typedef struct { |
| size_t size; // set to sizeof(GeofenceBreachNotification) |
| size_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 { |
| size_t size; // set to sizeof(GeofenceBreachNotification) |
| GeofenceStatusAvailable available; // GEOFENCE_STATUS_AVAILABILE_NO/_YES |
| LocationTechnologyType techType; // GNSS |
| } GeofenceStatusNotification; |
| |
| typedef struct { |
| size_t size; // set to sizeof(GnssLocationInfo) |
| GnssLocationInfoFlagMask flags; // bitwise OR of GnssLocationInfoBits for param validity |
| float altitudeMeanSeaLevel; // altitude wrt mean sea level |
| float pdop; // position dilusion of precision |
| float hdop; // horizontal dilusion of precision |
| float vdop; // vertical dilusion of precision |
| float magneticDeviation; // magnetic deviation |
| LocationReliability horReliability; // horizontal reliability |
| LocationReliability verReliability; // vertical reliability |
| float horUncEllipseSemiMajor; // horizontal elliptical accuracy semi-major axis |
| float horUncEllipseSemiMinor; // horizontal elliptical accuracy semi-minor axis |
| float horUncEllipseOrientAzimuth; // horizontal elliptical accuracy azimuth |
| } GnssLocationInfoNotification; |
| |
| typedef struct { |
| size_t size; // set to sizeof(GnssNiNotification) |
| GnssNiType type; // type of NI (Voice, SUPL, Control Plane) |
| GnssNiOptionsMask options; // bitwise OR of GnssNiOptionsBits |
| uint32_t timeout; // time (seconds) to wait for user input |
| GnssNiResponse timeoutResponse; // the response that should be sent when timeout expires |
| char requestor[GNSS_NI_REQUESTOR_MAX]; // the requestor that is making the request |
| GnssNiEncodingType requestorEncoding; // the encoding type for requestor |
| 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; |
| |
| typedef struct { |
| size_t size; // set to sizeof(GnssSv) |
| uint16_t svId; // Unique Identifier |
| GnssSvType type; // type of SV (GPS, SBAS, GLONASS, QZSS, BEIDOU, GALILEO) |
| float cN0Dbhz; // signal strength |
| float elevation; // elevation of SV (in degrees) |
| float azimuth; // azimuth of SV (in degrees) |
| GnssSvOptionsMask gnssSvOptionsMask; // Bitwise OR of GnssSvOptionsBits |
| } GnssSv; |
| |
| typedef struct { |
| size_t size; // set to sizeof(GnssConfigSetAssistanceServer) |
| GnssAssistanceType type; // SUPL or C2K |
| const char* hostName; // null terminated string |
| uint32_t port; // port of server |
| } GnssConfigSetAssistanceServer; |
| |
| typedef struct { |
| size_t size; // set to sizeof(GnssMeasurementsData) |
| GnssMeasurementsDataFlagsMask flags; // bitwise OR of GnssMeasurementsDataFlagsBits |
| int16_t svId; |
| GnssSvType svType; |
| double timeOffsetNs; |
| GnssMeasurementsStateMask stateMask; // bitwise OR of GnssMeasurementsStateBits |
| int64_t receivedSvTimeNs; |
| int64_t receivedSvTimeUncertaintyNs; |
| double carrierToNoiseDbHz; |
| double pseudorangeRateMps; |
| double pseudorangeRateUncertaintyMps; |
| GnssMeasurementsAdrStateMask adrStateMask; // bitwise OR of GnssMeasurementsAdrStateBits |
| double adrMeters; |
| double adrUncertaintyMeters; |
| float carrierFrequencyHz; |
| int64_t carrierCycles; |
| double carrierPhase; |
| double carrierPhaseUncertainty; |
| GnssMeasurementsMultipathIndicator multipathIndicator; |
| double signalToNoiseRatioDb; |
| double agcLevelDb; |
| } GnssMeasurementsData; |
| |
| typedef struct { |
| size_t size; // set to sizeof(GnssMeasurementsClock) |
| GnssMeasurementsClockFlagsMask flags; // bitwise OR of GnssMeasurementsClockFlagsBits |
| int16_t leapSecond; |
| int64_t timeNs; |
| double timeUncertaintyNs; |
| int64_t fullBiasNs; |
| double biasNs; |
| double biasUncertaintyNs; |
| double driftNsps; |
| double driftUncertaintyNsps; |
| uint32_t hwClockDiscontinuityCount; |
| } GnssMeasurementsClock; |
| |
| typedef struct { |
| size_t size; // set to sizeof(GnssSvNotification) |
| size_t count; // number of SVs in the GnssSv array |
| GnssSv gnssSvs[GNSS_SV_MAX]; // information on a number of SVs |
| } GnssSvNotification; |
| |
| typedef struct { |
| size_t size; // set to sizeof(GnssNmeaNotification) |
| uint64_t timestamp; // timestamp |
| const char* nmea; // nmea text |
| size_t length; // length of the nmea text |
| } GnssNmeaNotification; |
| |
| typedef struct { |
| size_t size; // set to sizeof(GnssMeasurementsNotification) |
| size_t count; // number of items in GnssMeasurements array |
| GnssMeasurementsData measurements[GNSS_MEASUREMENTS_MAX]; |
| GnssMeasurementsClock clock; // clock |
| } GnssMeasurementsNotification; |
| |
| typedef struct { |
| size_t size; // set to sizeof(GnssConfig) |
| GnssConfigFlagsMask flags; // bitwise OR of GnssConfigFlagsBits to mark which params are valid |
| GnssConfigGpsLock gpsLock; |
| GnssConfigSuplVersion suplVersion; |
| GnssConfigSetAssistanceServer assistanceServer; |
| GnssConfigLppProfile lppProfile; |
| GnssConfigLppeControlPlaneMask lppeControlPlaneMask; |
| GnssConfigLppeUserPlaneMask lppeUserPlaneMask; |
| GnssConfigAGlonassPositionProtocolMask aGlonassPositionProtocolMask; |
| GnssConfigEmergencyPdnForEmergencySupl emergencyPdnForEmergencySupl; |
| GnssConfigSuplEmergencyServices suplEmergencyServices; |
| GnssConfigSuplModeMask suplModeMask; //bitwise OR of GnssConfigSuplModeBits |
| } GnssConfig; |
| |
| typedef struct { |
| size_t size; // set to sizeof |
| bool mValid; |
| Location mLocation; |
| double verticalAccuracyMeters; |
| double speedAccuracyMetersPerSecond; |
| double bearingAccuracyDegrees; |
| timespec mUtcReported; |
| } GnssDebugLocation; |
| |
| typedef struct { |
| size_t size; // set to sizeof |
| bool mValid; |
| int64_t timeEstimate; |
| float timeUncertaintyNs; |
| float frequencyUncertaintyNsPerSec; |
| } GnssDebugTime; |
| |
| typedef struct { |
| size_t size; // set to sizeof |
| uint32_t svid; |
| GnssSvType constellation; |
| GnssEphemerisType mEphemerisType; |
| GnssEphemerisSource mEphemerisSource; |
| GnssEphemerisHealth mEphemerisHealth; |
| float ephemerisAgeSeconds; |
| bool serverPredictionIsAvailable; |
| float serverPredictionAgeSeconds; |
| } GnssDebugSatelliteInfo; |
| |
| typedef struct { |
| size_t size; // set to sizeof |
| GnssDebugLocation mLocation; |
| GnssDebugTime mTime; |
| std::vector<GnssDebugSatelliteInfo> mSatelliteInfo; |
| } GnssDebugReport; |
| |
| /* Provides the capabilities of the system |
| capabilities callback is called once soon after createInstance is called */ |
| typedef std::function<void( |
| LocationCapabilitiesMask capabilitiesMask // bitwise OR of LocationCapabilitiesBits |
| )> capabilitiesCallback; |
| |
| /* Used by tracking, batching, and miscellanous APIs |
| responseCallback is called for every Tracking, Batching API, and Miscellanous API */ |
| typedef std::function<void( |
| LocationError err, // if not SUCCESS, then id is not valid |
| uint32_t id // id to be associated to the request |
| )> responseCallback; |
| |
| /* Used by APIs that gets more than one LocationError in it's response |
| collectiveResponseCallback is called for every geofence API call. |
| ids array and LocationError array are only valid until collectiveResponseCallback returns. */ |
| typedef std::function<void( |
| size_t count, // number of locations in arrays |
| LocationError* errs, // array of LocationError associated to the request |
| uint32_t* ids // array of ids to be associated to the request |
| )> collectiveResponseCallback; |
| |
| /* Used for startTracking API, optional can be NULL |
| trackingCallback is called when delivering a location in a tracking session |
| broadcasted to all clients, no matter if a session has started by client */ |
| typedef std::function<void( |
| Location location |
| )> trackingCallback; |
| |
| /* Used for startBatching API, optional can be NULL |
| batchingCallback is called when delivering locations in a batching session. |
| broadcasted to all clients, no matter if a session has started by client */ |
| typedef std::function<void( |
| size_t count, // number of locations in array |
| Location* location // array of locations |
| )> batchingCallback; |
| |
| /* Gives GNSS Location information, optional can be NULL |
| gnssLocationInfoCallback is called only during a tracking session |
| broadcasted to all clients, no matter if a session has started by client */ |
| typedef std::function<void( |
| GnssLocationInfoNotification gnssLocationInfoNotification |
| )> gnssLocationInfoCallback; |
| |
| /* Used for addGeofences API, optional can be NULL |
| geofenceBreachCallback is called when any number of geofences have a state change */ |
| typedef std::function<void( |
| GeofenceBreachNotification geofenceBreachNotification |
| )> geofenceBreachCallback; |
| |
| /* Used for addGeofences API, optional can be NULL |
| geofenceStatusCallback is called when any number of geofences have a status change */ |
| typedef std::function<void( |
| GeofenceStatusNotification geofenceStatusNotification |
| )> geofenceStatusCallback; |
| |
| /* Network Initiated request, optional can be NULL |
| This callback should be responded to by calling gnssNiResponse */ |
| typedef std::function<void( |
| uint32_t id, // id that should be used to respond by calling gnssNiResponse |
| GnssNiNotification gnssNiNotification |
| )> gnssNiCallback; |
| |
| /* Gives GNSS SV information, optional can be NULL |
| gnssSvCallback is called only during a tracking session |
| broadcasted to all clients, no matter if a session has started by client */ |
| typedef std::function<void( |
| GnssSvNotification gnssSvNotification |
| )> gnssSvCallback; |
| |
| /* Gives GNSS NMEA data, optional can be NULL |
| gnssNmeaCallback is called only during a tracking session |
| broadcasted to all clients, no matter if a session has started by client */ |
| typedef std::function<void( |
| GnssNmeaNotification gnssNmeaNotification |
| )> gnssNmeaCallback; |
| |
| /* Gives GNSS Measurements information, optional can be NULL |
| gnssMeasurementsCallback is called only during a tracking session |
| broadcasted to all clients, no matter if a session has started by client */ |
| typedef std::function<void( |
| GnssMeasurementsNotification gnssMeasurementsNotification |
| )> gnssMeasurementsCallback; |
| |
| typedef struct { |
| size_t size; // set to sizeof(LocationCallbacks) |
| capabilitiesCallback capabilitiesCb; // mandatory |
| responseCallback responseCb; // mandatory |
| collectiveResponseCallback collectiveResponseCb; // mandatory |
| trackingCallback trackingCb; // optional |
| batchingCallback batchingCb; // optional |
| geofenceBreachCallback geofenceBreachCb; // optional |
| geofenceStatusCallback geofenceStatusCb; // optional |
| gnssLocationInfoCallback gnssLocationInfoCb; // optional |
| gnssNiCallback gnssNiCb; // optional |
| gnssSvCallback gnssSvCb; // optional |
| gnssNmeaCallback gnssNmeaCb; // optional |
| gnssMeasurementsCallback gnssMeasurementsCb; // optional |
| } LocationCallbacks; |
| |
| class LocationAPI |
| { |
| private: |
| LocationAPI(); |
| ~LocationAPI(); |
| |
| public: |
| /* creates an instance to LocationAPI object. |
| Will return NULL if mandatory parameters are invalid or if the maximum number |
| of instances have been reached */ |
| static LocationAPI* createInstance(LocationCallbacks&); |
| |
| /* destroy/cleans up the instance, which should be called when LocationAPI object is |
| no longer needed. LocationAPI* returned from createInstance will no longer valid |
| after destroy is called */ |
| void destroy(); |
| |
| /* updates/changes the callbacks that will be called. |
| mandatory callbacks must be present for callbacks to be successfully updated |
| no return value */ |
| void updateCallbacks(LocationCallbacks&); |
| |
| /* ================================== TRACKING ================================== */ |
| |
| /* startTracking starts a tracking session, which returns a session id that will be |
| used by the other tracking APIs and also in the responseCallback to match command |
| with response. locations are reported on the trackingCallback passed in createInstance |
| periodically according to LocationOptions. |
| responseCallback returns: |
| LOCATION_ERROR_SUCCESS if session was successfully started |
| LOCATION_ERROR_ALREADY_STARTED if a startTracking session is already in progress |
| LOCATION_ERROR_CALLBACK_MISSING if no trackingCallback was passed in createInstance |
| LOCATION_ERROR_INVALID_PARAMETER if LocationOptions parameter is invalid */ |
| uint32_t startTracking(LocationOptions&); // returns session id |
| |
| /* stopTracking stops a tracking session associated with id parameter. |
| responseCallback returns: |
| LOCATION_ERROR_SUCCESS if successful |
| LOCATION_ERROR_ID_UNKNOWN if id is not associated with a tracking session */ |
| void stopTracking(uint32_t id); |
| |
| /* updateTrackingOptions changes the LocationOptions of a tracking session associated with id |
| responseCallback returns: |
| LOCATION_ERROR_SUCCESS if successful |
| LOCATION_ERROR_INVALID_PARAMETER if LocationOptions parameters are invalid |
| LOCATION_ERROR_ID_UNKNOWN if id is not associated with a tracking session */ |
| void updateTrackingOptions(uint32_t id, LocationOptions&); |
| |
| /* ================================== BATCHING ================================== */ |
| |
| /* startBatching starts a batching session, which returns a session id that will be |
| used by the other batching APIs and also in the responseCallback to match command |
| with response. locations are reported on the batchingCallback passed in createInstance |
| periodically according to LocationOptions. A batching session starts tracking on |
| the low power processor and delivers them in batches by the batchingCallback when |
| the batch is full or when getBatchedLocations is called. This allows for the processor |
| that calls this API to sleep when the low power processor can batch locations in the |
| backgroup and wake up the processor calling the API only when the batch is full, thus |
| saving power |
| responseCallback returns: |
| LOCATION_ERROR_SUCCESS if session was successful |
| LOCATION_ERROR_ALREADY_STARTED if a startBatching session is already in progress |
| LOCATION_ERROR_CALLBACK_MISSING if no batchingCallback was passed in createInstance |
| LOCATION_ERROR_INVALID_PARAMETER if a parameter is invalid |
| LOCATION_ERROR_NOT_SUPPORTED if batching is not supported */ |
| uint32_t startBatching(LocationOptions&); // returns session id |
| |
| /* stopBatching stops a batching session associated with id parameter. |
| responseCallback returns: |
| LOCATION_ERROR_SUCCESS if successful |
| LOCATION_ERROR_ID_UNKNOWN if id is not associated with batching session */ |
| void stopBatching(uint32_t id); |
| |
| /* updateBatchingOptions changes the LocationOptions of a batching session associated with id |
| responseCallback returns: |
| LOCATION_ERROR_SUCCESS if successful |
| LOCATION_ERROR_INVALID_PARAMETER if LocationOptions parameters are invalid |
| LOCATION_ERROR_ID_UNKNOWN if id is not associated with a batching session */ |
| void updateBatchingOptions(uint32_t id, LocationOptions&); |
| |
| /* getBatchedLocations gets a number of locations that are currently stored/batched |
| on the low power processor, delivered by the batchingCallback passed in createInstance. |
| Location are then deleted from the batch stored on the low power processor. |
| responseCallback returns: |
| LOCATION_ERROR_SUCCESS if successful, will be followed by batchingCallback call |
| LOCATION_ERROR_CALLBACK_MISSING if no batchingCallback was passed in createInstance |
| LOCATION_ERROR_ID_UNKNOWN if id is not associated with a batching session */ |
| void getBatchedLocations(uint32_t id, size_t count); |
| |
| /* ================================== GEOFENCE ================================== */ |
| |
| /* addGeofences adds any number of geofences and returns an array of geofence ids that |
| will be used by the other geofence APIs and also in the collectiveResponseCallback to |
| match command with response. The geofenceBreachCallback will deliver the status of each |
| geofence according to the GeofenceOption for each. The geofence id array returned will |
| be valid until the collectiveResponseCallback is called and has returned. |
| collectiveResponseCallback returns: |
| LOCATION_ERROR_SUCCESS if session was successful |
| LOCATION_ERROR_CALLBACK_MISSING if no geofenceBreachCallback |
| LOCATION_ERROR_INVALID_PARAMETER if any parameters are invalid |
| LOCATION_ERROR_NOT_SUPPORTED if geofence is not supported */ |
| uint32_t* addGeofences(size_t count, GeofenceOption*, GeofenceInfo*); // returns id array |
| |
| /* removeGeofences removes any number of geofences. Caller should delete ids array after |
| removeGeofences returneds. |
| collectiveResponseCallback returns: |
| LOCATION_ERROR_SUCCESS if successful |
| LOCATION_ERROR_ID_UNKNOWN if id is not associated with a geofence session */ |
| void removeGeofences(size_t count, uint32_t* ids); |
| |
| /* modifyGeofences modifies any number of geofences. Caller should delete ids array after |
| modifyGeofences returns. |
| collectiveResponseCallback returns: |
| LOCATION_ERROR_SUCCESS if successful |
| LOCATION_ERROR_ID_UNKNOWN if id is not associated with a geofence session |
| LOCATION_ERROR_INVALID_PARAMETER if any parameters are invalid */ |
| void modifyGeofences(size_t count, uint32_t* ids, GeofenceOption* options); |
| |
| /* pauseGeofences pauses any number of geofences, which is similar to removeGeofences, |
| only that they can be resumed at any time. Caller should delete ids array after |
| pauseGeofences returns. |
| collectiveResponseCallback returns: |
| LOCATION_ERROR_SUCCESS if successful |
| LOCATION_ERROR_ID_UNKNOWN if id is not associated with a geofence session */ |
| void pauseGeofences(size_t count, uint32_t* ids); |
| |
| /* resumeGeofences resumes any number of geofences that are currently paused. Caller should |
| delete ids array after resumeGeofences returns. |
| collectiveResponseCallback returns: |
| LOCATION_ERROR_SUCCESS if successful |
| LOCATION_ERROR_ID_UNKNOWN if id is not associated with a geofence session */ |
| void resumeGeofences(size_t count, uint32_t* ids); |
| |
| /* ================================== GNSS ====================================== */ |
| |
| /* gnssNiResponse is called in response to a gnssNiCallback. |
| responseCallback returns: |
| LOCATION_ERROR_SUCCESS if session was successful |
| LOCATION_ERROR_INVALID_PARAMETER if any parameters in GnssNiResponse are invalid |
| LOCATION_ERROR_ID_UNKNOWN if id does not match a gnssNiCallback */ |
| void gnssNiResponse(uint32_t id, GnssNiResponse response); |
| }; |
| |
| typedef struct { |
| size_t size; // set to sizeof(LocationControlCallbacks) |
| responseCallback responseCb; // mandatory |
| collectiveResponseCallback collectiveResponseCb; // mandatory |
| } LocationControlCallbacks; |
| |
| class LocationControlAPI |
| { |
| private: |
| LocationControlAPI(); |
| ~LocationControlAPI(); |
| |
| public: |
| /* creates an instance to LocationControlAPI object. |
| Will return NULL if mandatory parameters are invalid or if the maximum number |
| of instances have been reached. Only once instance allowed */ |
| static LocationControlAPI* createInstance(LocationControlCallbacks&); |
| |
| /* destroy/cleans up the instance, which should be called when LocationControlAPI object is |
| no longer needed. LocationControlAPI* returned from createInstance will no longer valid |
| after destroy is called */ |
| void destroy(); |
| |
| /* enable will enable specific location technology to be used for calculation locations and |
| will effectively start a control session if call is successful, which returns a session id |
| that will be returned in responseCallback to match command with response. The session id is |
| also needed to call the disable command. |
| This effect is global for all clients of LocationAPI |
| responseCallback returns: |
| LOCATION_ERROR_SUCCESS if successful |
| LOCATION_ERROR_ALREADY_STARTED if an enable was already called for this techType |
| LOCATION_ERROR_INVALID_PARAMETER if any parameters are invalid |
| LOCATION_ERROR_GENERAL_FAILURE if failure for any other reason */ |
| uint32_t enable(LocationTechnologyType techType); |
| |
| /* disable will disable specific location technology to be used for calculation locations and |
| effectively ends the control session if call is successful. |
| id parameter is the session id that was returned in enable responseCallback for techType. |
| The session id is no longer valid after disable's responseCallback returns success. |
| This effect is global for all clients of LocationAPI |
| responseCallback returns: |
| LOCATION_ERROR_SUCCESS if successful |
| LOCATION_ERROR_ID_UNKNOWN if id was not returned from responseCallback from enable |
| LOCATION_ERROR_GENERAL_FAILURE if failure for any other reason */ |
| void disable(uint32_t id); |
| |
| /* gnssUpdateConfig updates the gnss specific configuration, which returns a session id array |
| with an id for each of the bits set in GnssConfig.flags, order from low bits to high bits. |
| The response for each config that is set will be returned in collectiveResponseCallback. |
| The session id array returned will be valid until the collectiveResponseCallback is called |
| and has returned. This effect is global for all clients of LocationAPI |
| collectiveResponseCallback returns: |
| LOCATION_ERROR_SUCCESS if session was successful |
| LOCATION_ERROR_INVALID_PARAMETER if any other parameters are invalid |
| LOCATION_ERROR_GENERAL_FAILURE if failure for any other reason */ |
| uint32_t* gnssUpdateConfig(GnssConfig config); |
| |
| /* delete specific gnss aiding data for testing, which returns a session id |
| that will be returned in responseCallback to match command with response. |
| Only allowed in userdebug builds. This effect is global for all clients of LocationAPI |
| responseCallback returns: |
| LOCATION_ERROR_SUCCESS if successful |
| LOCATION_ERROR_INVALID_PARAMETER if any parameters are invalid |
| LOCATION_ERROR_NOT_SUPPORTED if build is not userdebug */ |
| uint32_t gnssDeleteAidingData(GnssAidingData& data); |
| }; |
| |
| #endif /* LOCATION_H */ |
