974 lines
44 KiB
C++
974 lines
44 KiB
C++
/* 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>
|
|
#include <list>
|
|
|
|
#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),
|
|
// supports debug nmea sentences in the debugNmeaCallback
|
|
LOCATION_CAPABILITIES_DEBUG_NMEA_BIT = (1<<8),
|
|
// support outdoor trip batching
|
|
LOCATION_CAPABILITIES_OUTDOOR_TRIP_BATCHING_BIT = (1<<9)
|
|
} 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
|
|
GNSS_CONFIG_LPPE_CONTROL_PLANE_SRN_AP_MEASUREMENTS_BIT = (1<<2), // SRN_AP_MEASUREMENTS
|
|
GNSS_CONFIG_LPPE_CONTROL_PLANE_SENSOR_BARO_MEASUREMENTS_BIT = (1<<3),
|
|
// SENSOR_BARO_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
|
|
GNSS_CONFIG_LPPE_USER_PLANE_SRN_AP_MEASUREMENTS_BIT = (1<<2), // SRN_AP_MEASUREMENTS
|
|
GNSS_CONFIG_LPPE_USER_PLANE_SENSOR_BARO_MEASUREMENTS_BIT = (1<<3),
|
|
// SENSOR_BARO_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 enum {
|
|
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 {
|
|
BATCHING_STATUS_TRIP_COMPLETED = 0,
|
|
BATCHING_STATUS_POSITION_AVAILABE,
|
|
BATCHING_STATUS_POSITION_UNAVAILABLE
|
|
} BatchingStatus;
|
|
|
|
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;
|
|
BatchingMode batchingMode;
|
|
} BatchingOptions;
|
|
|
|
typedef struct {
|
|
size_t size;
|
|
BatchingStatus batchingStatus;
|
|
} BatchingStatusInfo;
|
|
|
|
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
|
|
BatchingOptions batchingOptions // Batching options
|
|
)> batchingCallback;
|
|
|
|
typedef std::function<void(
|
|
BatchingStatusInfo batchingStatus, // batch status
|
|
std::list<uint32_t> & listOfCompletedTrips
|
|
)> batchingStatusCallback;
|
|
|
|
/* 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
|
|
batchingStatusCallback batchingStatusCb; // 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&, BatchingOptions&); // 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&, BatchingOptions&);
|
|
|
|
/* 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 */
|