/* Copyright (c) 2011-2014, 2016-2020 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 LOC_API_BASE_H #define LOC_API_BASE_H #include #include #include #include #include #include #include #ifdef NO_UNORDERED_SET_OR_MAP #include #else #include #endif #include #include using namespace loc_util; namespace loc_core { class ContextBase; struct LocApiResponse; template struct LocApiResponseData; int hexcode(char *hexstring, int string_size, const char *data, int data_size); int decodeAddress(char *addr_string, int string_size, const char *data, int data_size); #define MAX_ADAPTERS 10 #define MAX_FEATURE_LENGTH 100 #define TO_ALL_ADAPTERS(adapters, call) \ for (int i = 0; i < MAX_ADAPTERS && NULL != (adapters)[i]; i++) { \ call; \ } #define TO_1ST_HANDLING_ADAPTER(adapters, call) \ for (int i = 0; i mProcImpl; inline virtual void proc() const { mProcImpl(); } public: inline LocApiMsg(std::function procImpl ) : mProcImpl(procImpl) {} }; class LocApiProxyBase { public: inline LocApiProxyBase() {} inline virtual ~LocApiProxyBase() {} inline virtual void* getSibling2() { return NULL; } inline virtual double getGloRfLoss(uint32_t left __unused, uint32_t center __unused, uint32_t right __unused, uint8_t gloFrequency __unused) { return 0.0; } inline virtual float getGeoidalSeparation(double latitude __unused, double longitude __unused) { return 0.0; } }; class LocApiBase { friend struct LocSsrMsg; //LocOpenMsg calls open() which makes it necessary to declare //it as a friend friend struct LocOpenMsg; friend struct LocCloseMsg; friend struct LocKillMsg; friend class ContextBase; static MsgTask* mMsgTask; static volatile int32_t mMsgTaskRefCount; LocAdapterBase* mLocAdapters[MAX_ADAPTERS]; protected: ContextBase *mContext; virtual enum loc_api_adapter_err open(LOC_API_ADAPTER_EVENT_MASK_T mask); virtual enum loc_api_adapter_err close(); LOC_API_ADAPTER_EVENT_MASK_T getEvtMask(); LOC_API_ADAPTER_EVENT_MASK_T mMask; uint32_t mNmeaMask; LocApiBase(LOC_API_ADAPTER_EVENT_MASK_T excludedMask, ContextBase* context = NULL); inline virtual ~LocApiBase() { android_atomic_dec(&mMsgTaskRefCount); if (nullptr != mMsgTask && 0 == mMsgTaskRefCount) { delete mMsgTask; mMsgTask = nullptr; } } bool isInSession(); const LOC_API_ADAPTER_EVENT_MASK_T mExcludedMask; bool isMaster(); public: inline void sendMsg(const LocMsg* msg) const { if (nullptr != mMsgTask) { mMsgTask->sendMsg(msg); } } inline void destroy() { close(); struct LocKillMsg : public LocMsg { LocApiBase* mLocApi; inline LocKillMsg(LocApiBase* locApi) : LocMsg(), mLocApi(locApi) {} inline virtual void proc() const { delete mLocApi; } }; sendMsg(new LocKillMsg(this)); } static bool needReport(const UlpLocation& ulpLocation, enum loc_sess_status status, LocPosTechMask techMask); void addAdapter(LocAdapterBase* adapter); void removeAdapter(LocAdapterBase* adapter); // upward calls void handleEngineUpEvent(); void handleEngineDownEvent(); void reportPosition(UlpLocation& location, GpsLocationExtended& locationExtended, enum loc_sess_status status, LocPosTechMask loc_technology_mask = LOC_POS_TECH_MASK_DEFAULT, GnssDataNotification* pDataNotify = nullptr, int msInWeek = -1); void reportSv(GnssSvNotification& svNotify); void reportSvPolynomial(GnssSvPolynomial &svPolynomial); void reportSvEphemeris(GnssSvEphemerisReport &svEphemeris); void reportStatus(LocGpsStatusValue status); void reportNmea(const char* nmea, int length); void reportData(GnssDataNotification& dataNotify, int msInWeek); void reportXtraServer(const char* url1, const char* url2, const char* url3, const int maxlength); void reportLocationSystemInfo(const LocationSystemInfo& locationSystemInfo); void requestXtraData(); void requestTime(); void requestLocation(); void requestATL(int connHandle, LocAGpsType agps_type, LocApnTypeMask apn_type_mask); void releaseATL(int connHandle); void requestNiNotify(GnssNiNotification ¬ify, const void* data, const LocInEmergency emergencyState); void reportGnssMeasurements(GnssMeasurements& gnssMeasurements, int msInWeek); void reportWwanZppFix(LocGpsLocation &zppLoc); void reportZppBestAvailableFix(LocGpsLocation &zppLoc, GpsLocationExtended &location_extended, LocPosTechMask tech_mask); void reportGnssSvIdConfig(const GnssSvIdConfig& config); void reportGnssSvTypeConfig(const GnssSvTypeConfig& config); void requestOdcpi(OdcpiRequestInfo& request); void reportGnssEngEnergyConsumedEvent(uint64_t energyConsumedSinceFirstBoot); void reportDeleteAidingDataEvent(GnssAidingData& aidingData); void reportKlobucharIonoModel(GnssKlobucharIonoModel& ionoModel); void reportGnssAdditionalSystemInfo(GnssAdditionalSystemInfo& additionalSystemInfo); void sendNfwNotification(GnssNfwNotification& notification); void reportGnssConfig(uint32_t sessionId, const GnssConfig& gnssConfig); void reportLatencyInfo(GnssLatencyInfo& gnssLatencyInfo); void reportQwesCapabilities ( const std::unordered_map &featureMap ); void geofenceBreach(size_t count, uint32_t* hwIds, Location& location, GeofenceBreachType breachType, uint64_t timestamp); void geofenceStatus(GeofenceStatusAvailable available); void reportDBTPosition(UlpLocation &location, GpsLocationExtended &locationExtended, enum loc_sess_status status, LocPosTechMask loc_technology_mask); void reportLocations(Location* locations, size_t count, BatchingMode batchingMode); void reportCompletedTrips(uint32_t accumulated_distance); void handleBatchStatusEvent(BatchingStatus batchStatus); // downward calls virtual void* getSibling(); virtual LocApiProxyBase* getLocApiProxy(); virtual void startFix(const LocPosMode& fixCriteria, LocApiResponse* adapterResponse); virtual void stopFix(LocApiResponse* adapterResponse); virtual void deleteAidingData(const GnssAidingData& data, LocApiResponse* adapterResponse); virtual void injectPosition(double latitude, double longitude, float accuracy, bool onDemandCpi); virtual void injectPosition(const GnssLocationInfoNotification &locationInfo, bool onDemandCpi=false); virtual void injectPosition(const Location& location, bool onDemandCpi); virtual void setTime(LocGpsUtcTime time, int64_t timeReference, int uncertainty); virtual void atlOpenStatus(int handle, int is_succ, char* apn, uint32_t apnLen, AGpsBearerType bear, LocAGpsType agpsType, LocApnTypeMask mask); virtual void atlCloseStatus(int handle, int is_succ); virtual LocationError setServerSync(const char* url, int len, LocServerType type); virtual LocationError setServerSync(unsigned int ip, int port, LocServerType type); virtual void informNiResponse(GnssNiResponse userResponse, const void* passThroughData); virtual LocationError setSUPLVersionSync(GnssConfigSuplVersion version); virtual enum loc_api_adapter_err setNMEATypesSync(uint32_t typesMask); virtual LocationError setLPPConfigSync(GnssConfigLppProfileMask profileMask); virtual enum loc_api_adapter_err setSensorPropertiesSync( bool gyroBiasVarianceRandomWalk_valid, float gyroBiasVarianceRandomWalk, bool accelBiasVarianceRandomWalk_valid, float accelBiasVarianceRandomWalk, bool angleBiasVarianceRandomWalk_valid, float angleBiasVarianceRandomWalk, bool rateBiasVarianceRandomWalk_valid, float rateBiasVarianceRandomWalk, bool velocityBiasVarianceRandomWalk_valid, float velocityBiasVarianceRandomWalk); virtual enum loc_api_adapter_err setSensorPerfControlConfigSync(int controlMode, int accelSamplesPerBatch, int accelBatchesPerSec, int gyroSamplesPerBatch, int gyroBatchesPerSec, int accelSamplesPerBatchHigh, int accelBatchesPerSecHigh, int gyroSamplesPerBatchHigh, int gyroBatchesPerSecHigh, int algorithmConfig); virtual LocationError setAGLONASSProtocolSync(GnssConfigAGlonassPositionProtocolMask aGlonassProtocol); virtual LocationError setLPPeProtocolCpSync(GnssConfigLppeControlPlaneMask lppeCP); virtual LocationError setLPPeProtocolUpSync(GnssConfigLppeUserPlaneMask lppeUP); virtual GnssConfigSuplVersion convertSuplVersion(const uint32_t suplVersion); virtual GnssConfigLppeControlPlaneMask convertLppeCp(const uint32_t lppeControlPlaneMask); virtual GnssConfigLppeUserPlaneMask convertLppeUp(const uint32_t lppeUserPlaneMask); virtual LocationError setEmergencyExtensionWindowSync(const uint32_t emergencyExtensionSeconds); virtual void setMeasurementCorrections( const GnssMeasurementCorrections& gnssMeasurementCorrections); virtual void getWwanZppFix(); virtual void getBestAvailableZppFix(); virtual LocationError setGpsLockSync(GnssConfigGpsLock lock); virtual void requestForAidingData(GnssAidingDataSvMask svDataMask); virtual LocationError setXtraVersionCheckSync(uint32_t check); /* Requests for SV/Constellation Control */ virtual LocationError setBlacklistSvSync(const GnssSvIdConfig& config); virtual void setBlacklistSv(const GnssSvIdConfig& config, LocApiResponse *adapterResponse=nullptr); virtual void getBlacklistSv(); virtual void setConstellationControl(const GnssSvTypeConfig& config, LocApiResponse *adapterResponse=nullptr); virtual void getConstellationControl(); virtual void resetConstellationControl(LocApiResponse *adapterResponse=nullptr); virtual void setConstrainedTuncMode(bool enabled, float tuncConstraint, uint32_t energyBudget, LocApiResponse* adapterResponse=nullptr); virtual void setPositionAssistedClockEstimatorMode(bool enabled, LocApiResponse* adapterResponse=nullptr); virtual void getGnssEnergyConsumed(); virtual void addGeofence(uint32_t clientId, const GeofenceOption& options, const GeofenceInfo& info, LocApiResponseData* adapterResponseData); virtual void removeGeofence(uint32_t hwId, uint32_t clientId, LocApiResponse* adapterResponse); virtual void pauseGeofence(uint32_t hwId, uint32_t clientId, LocApiResponse* adapterResponse); virtual void resumeGeofence(uint32_t hwId, uint32_t clientId, LocApiResponse* adapterResponse); virtual void modifyGeofence(uint32_t hwId, uint32_t clientId, const GeofenceOption& options, LocApiResponse* adapterResponse); virtual void startTimeBasedTracking(const TrackingOptions& options, LocApiResponse* adapterResponse); virtual void stopTimeBasedTracking(LocApiResponse* adapterResponse); virtual void startDistanceBasedTracking(uint32_t sessionId, const LocationOptions& options, LocApiResponse* adapterResponse); virtual void stopDistanceBasedTracking(uint32_t sessionId, LocApiResponse* adapterResponse = nullptr); virtual void startBatching(uint32_t sessionId, const LocationOptions& options, uint32_t accuracy, uint32_t timeout, LocApiResponse* adapterResponse); virtual void stopBatching(uint32_t sessionId, LocApiResponse* adapterResponse); virtual LocationError startOutdoorTripBatchingSync(uint32_t tripDistance, uint32_t tripTbf, uint32_t timeout); virtual void startOutdoorTripBatching(uint32_t tripDistance, uint32_t tripTbf, uint32_t timeout, LocApiResponse* adapterResponse); virtual void reStartOutdoorTripBatching(uint32_t ongoingTripDistance, uint32_t ongoingTripInterval, uint32_t batchingTimeout, LocApiResponse* adapterResponse); virtual LocationError stopOutdoorTripBatchingSync(bool deallocBatchBuffer = true); virtual void stopOutdoorTripBatching(bool deallocBatchBuffer = true, LocApiResponse* adapterResponse = nullptr); virtual LocationError getBatchedLocationsSync(size_t count); virtual void getBatchedLocations(size_t count, LocApiResponse* adapterResponse); virtual LocationError getBatchedTripLocationsSync(size_t count, uint32_t accumulatedDistance); virtual void getBatchedTripLocations(size_t count, uint32_t accumulatedDistance, LocApiResponse* adapterResponse); virtual LocationError queryAccumulatedTripDistanceSync(uint32_t &accumulated_trip_distance, uint32_t &numOfBatchedPositions); virtual void queryAccumulatedTripDistance( LocApiResponseData* adapterResponseData); virtual void setBatchSize(size_t size); virtual void setTripBatchSize(size_t size); virtual void addToCallQueue(LocApiResponse* adapterResponse); void updateEvtMask(); void updateNmeaMask(uint32_t mask); virtual void updateSystemPowerState(PowerStateType systemPowerState); virtual void configRobustLocation(bool enable, bool enableForE911, LocApiResponse* adapterResponse=nullptr); virtual void getRobustLocationConfig(uint32_t sessionId, LocApiResponse* adapterResponse); virtual void configMinGpsWeek(uint16_t minGpsWeek, LocApiResponse* adapterResponse=nullptr); virtual void getMinGpsWeek(uint32_t sessionId, LocApiResponse* adapterResponse); virtual LocationError setParameterSync(const GnssConfig & gnssConfig); virtual void getParameter(uint32_t sessionId, GnssConfigFlagsMask flags, LocApiResponse* adapterResponse=nullptr); virtual void configConstellationMultiBand(const GnssSvTypeConfig& secondaryBandConfig, LocApiResponse* adapterResponse=nullptr); virtual void getConstellationMultiBandConfig(uint32_t sessionId, LocApiResponse* adapterResponse=nullptr); }; class ElapsedRealtimeEstimator { private: int64_t mCurrentClockDiff; int64_t mPrevUtcTimeNanos; int64_t mPrevBootTimeNanos; int64_t mFixTimeStablizationThreshold; int64_t mInitialTravelTime; int64_t mPrevDataTimeNanos; public: ElapsedRealtimeEstimator(int64_t travelTimeNanosEstimate): mInitialTravelTime(travelTimeNanosEstimate) {reset();} int64_t getElapsedRealtimeEstimateNanos(int64_t curDataTimeNanos, bool isCurDataTimeTrustable, int64_t tbf); inline int64_t getElapsedRealtimeUncNanos() { return 5000000;} void reset(); static int64_t getElapsedRealtimeQtimer(int64_t qtimerTicksAtOrigin); static bool getCurrentTime(struct timespec& currentTime, int64_t& sinceBootTimeNanos); }; typedef LocApiBase* (getLocApi_t)(LOC_API_ADAPTER_EVENT_MASK_T exMask, ContextBase *context); } // namespace loc_core #endif //LOC_API_BASE_H