sdm660-common: Remove GPS HAL for subtree import

Change-Id: Ib18b7d867224557562c3f6a4a20c206f0ec30fec

1 files changed, 0 insertions, 974 deletions

diff --git a/gps/location/LocationAPI.h b/gps/location/LocationAPI.h
deleted file mode 100644
index 530b1b0..0000000
--- a/gps/location/LocationAPI.h
+++ /dev/null
@@ -1,974 +0,0 @@
-/* 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 */