1 /* Copyright (c) 2011-2015, The Linux Foundation. All rights reserved. 2 * 3 * Redistribution and use in source and binary forms, with or without 4 * modification, are permitted provided that the following conditions are 5 * met: 6 * * Redistributions of source code must retain the above copyright 7 * notice, this list of conditions and the following disclaimer. 8 * * Redistributions in binary form must reproduce the above 9 * copyright notice, this list of conditions and the following 10 * disclaimer in the documentation and/or other materials provided 11 * with the distribution. 12 * * Neither the name of The Linux Foundation, nor the names of its 13 * contributors may be used to endorse or promote products derived 14 * from this software without specific prior written permission. 15 * 16 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED 17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 18 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT 19 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS 20 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR 23 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 24 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 25 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN 26 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27 * 28 */ 29 #ifndef LOC_API_ENG_ADAPTER_H 30 #define LOC_API_ENG_ADAPTER_H 31 32 #include <ctype.h> 33 #include <hardware/gps.h> 34 #include <loc.h> 35 #include <loc_eng_log.h> 36 #include <log_util.h> 37 #include <LocAdapterBase.h> 38 #include <LocDualContext.h> 39 #include <UlpProxyBase.h> 40 #include <platform_lib_includes.h> 41 42 #define MAX_URL_LEN 256 43 44 using namespace loc_core; 45 46 class LocEngAdapter; 47 48 class LocInternalAdapter : public LocAdapterBase { 49 LocEngAdapter* mLocEngAdapter; 50 public: 51 LocInternalAdapter(LocEngAdapter* adapter); 52 53 virtual void reportPosition(UlpLocation &location, 54 GpsLocationExtended &locationExtended, 55 void* locationExt, 56 enum loc_sess_status status, 57 LocPosTechMask loc_technology_mask); 58 virtual void reportSv(QtiGnssSvStatus &svStatus, 59 GpsLocationExtended &locationExtended, 60 void* svExt); 61 virtual void reportStatus(GpsStatusValue status); 62 virtual void setPositionModeInt(LocPosMode& posMode); 63 virtual void startFixInt(); 64 virtual void stopFixInt(); 65 virtual void getZppInt(); 66 virtual void setUlpProxy(UlpProxyBase* ulp); 67 }; 68 69 typedef void (*loc_msg_sender)(void* loc_eng_data_p, void* msgp); 70 71 class LocEngAdapter : public LocAdapterBase { 72 void* mOwner; 73 LocInternalAdapter* mInternalAdapter; 74 UlpProxyBase* mUlp; 75 LocPosMode mFixCriteria; 76 bool mNavigating; 77 // mPowerVote is encoded as 78 // mPowerVote & 0x20 -- powerVoteRight 79 // mPowerVote & 0x10 -- power On / Off 80 unsigned int mPowerVote; 81 static const unsigned int POWER_VOTE_RIGHT = 0x20; 82 static const unsigned int POWER_VOTE_VALUE = 0x10; 83 84 public: 85 bool mSupportsAgpsRequests; 86 bool mSupportsPositionInjection; 87 bool mSupportsTimeInjection; 88 89 LocEngAdapter(LOC_API_ADAPTER_EVENT_MASK_T mask, 90 void* owner, ContextBase* context, 91 LocThread::tCreate tCreator); 92 virtual ~LocEngAdapter(); 93 94 virtual void setUlpProxy(UlpProxyBase* ulp); 95 void setXtraUserAgent(); requestUlp(unsigned long capabilities)96 inline void requestUlp(unsigned long capabilities) { 97 mContext->requestUlp(mInternalAdapter, capabilities); 98 } getInternalAdapter()99 inline LocInternalAdapter* getInternalAdapter() { return mInternalAdapter; } getUlpProxy()100 inline UlpProxyBase* getUlpProxy() { return mUlp; } getOwner()101 inline void* getOwner() { return mOwner; } hasAgpsExtendedCapabilities()102 inline bool hasAgpsExtendedCapabilities() { 103 return mContext->hasAgpsExtendedCapabilities(); 104 } hasCPIExtendedCapabilities()105 inline bool hasCPIExtendedCapabilities() { 106 return mContext->hasCPIExtendedCapabilities(); 107 } getMsgTask()108 inline const MsgTask* getMsgTask() { return mMsgTask; } 109 110 inline enum loc_api_adapter_err startFix()111 startFix() 112 { 113 return mLocApi->startFix(mFixCriteria); 114 } 115 inline enum loc_api_adapter_err stopFix()116 stopFix() 117 { 118 return mLocApi->stopFix(); 119 } 120 inline enum loc_api_adapter_err deleteAidingData(GpsAidingData f)121 deleteAidingData(GpsAidingData f) 122 { 123 return mLocApi->deleteAidingData(f); 124 } 125 inline enum loc_api_adapter_err enableData(int enable)126 enableData(int enable) 127 { 128 return mLocApi->enableData(enable); 129 } 130 inline enum loc_api_adapter_err setAPN(char * apn,int len)131 setAPN(char* apn, int len) 132 { 133 return mLocApi->setAPN(apn, len); 134 } 135 inline enum loc_api_adapter_err injectPosition(double latitude,double longitude,float accuracy)136 injectPosition(double latitude, double longitude, float accuracy) 137 { 138 return mLocApi->injectPosition(latitude, longitude, accuracy); 139 } 140 inline enum loc_api_adapter_err setXtraData(char * data,int length)141 setXtraData(char* data, int length) 142 { 143 return mLocApi->setXtraData(data, length); 144 } 145 inline enum loc_api_adapter_err requestXtraServer()146 requestXtraServer() 147 { 148 return mLocApi->requestXtraServer(); 149 } 150 inline enum loc_api_adapter_err atlOpenStatus(int handle,int is_succ,char * apn,AGpsBearerType bearer,AGpsType agpsType)151 atlOpenStatus(int handle, int is_succ, char* apn, AGpsBearerType bearer, AGpsType agpsType) 152 { 153 return mLocApi->atlOpenStatus(handle, is_succ, apn, bearer, agpsType); 154 } 155 inline enum loc_api_adapter_err atlCloseStatus(int handle,int is_succ)156 atlCloseStatus(int handle, int is_succ) 157 { 158 return mLocApi->atlCloseStatus(handle, is_succ); 159 } 160 inline enum loc_api_adapter_err setPositionMode(const LocPosMode * posMode)161 setPositionMode(const LocPosMode *posMode) 162 { 163 if (NULL != posMode) { 164 mFixCriteria = *posMode; 165 } 166 return mLocApi->setPositionMode(mFixCriteria); 167 } 168 inline enum loc_api_adapter_err setServer(const char * url,int len)169 setServer(const char* url, int len) 170 { 171 return mLocApi->setServer(url, len); 172 } 173 inline enum loc_api_adapter_err setServer(unsigned int ip,int port,LocServerType type)174 setServer(unsigned int ip, int port, 175 LocServerType type) 176 { 177 return mLocApi->setServer(ip, port, type); 178 } 179 inline enum loc_api_adapter_err informNiResponse(GpsUserResponseType userResponse,const void * passThroughData)180 informNiResponse(GpsUserResponseType userResponse, const void* passThroughData) 181 { 182 return mLocApi->informNiResponse(userResponse, passThroughData); 183 } 184 inline enum loc_api_adapter_err setSUPLVersion(uint32_t version)185 setSUPLVersion(uint32_t version) 186 { 187 return mLocApi->setSUPLVersion(version); 188 } 189 inline enum loc_api_adapter_err setLPPConfig(uint32_t profile)190 setLPPConfig(uint32_t profile) 191 { 192 return mLocApi->setLPPConfig(profile); 193 } 194 inline enum loc_api_adapter_err setSensorControlConfig(int sensorUsage,int sensorProvider)195 setSensorControlConfig(int sensorUsage, int sensorProvider) 196 { 197 return mLocApi->setSensorControlConfig(sensorUsage, sensorProvider); 198 } 199 inline enum loc_api_adapter_err setSensorProperties(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)200 setSensorProperties(bool gyroBiasVarianceRandomWalk_valid, float gyroBiasVarianceRandomWalk, 201 bool accelBiasVarianceRandomWalk_valid, float accelBiasVarianceRandomWalk, 202 bool angleBiasVarianceRandomWalk_valid, float angleBiasVarianceRandomWalk, 203 bool rateBiasVarianceRandomWalk_valid, float rateBiasVarianceRandomWalk, 204 bool velocityBiasVarianceRandomWalk_valid, float velocityBiasVarianceRandomWalk) 205 { 206 return mLocApi->setSensorProperties(gyroBiasVarianceRandomWalk_valid, gyroBiasVarianceRandomWalk, 207 accelBiasVarianceRandomWalk_valid, accelBiasVarianceRandomWalk, 208 angleBiasVarianceRandomWalk_valid, angleBiasVarianceRandomWalk, 209 rateBiasVarianceRandomWalk_valid, rateBiasVarianceRandomWalk, 210 velocityBiasVarianceRandomWalk_valid, velocityBiasVarianceRandomWalk); 211 } 212 inline virtual enum loc_api_adapter_err setSensorPerfControlConfig(int controlMode,int accelSamplesPerBatch,int accelBatchesPerSec,int gyroSamplesPerBatch,int gyroBatchesPerSec,int accelSamplesPerBatchHigh,int accelBatchesPerSecHigh,int gyroSamplesPerBatchHigh,int gyroBatchesPerSecHigh,int algorithmConfig)213 setSensorPerfControlConfig(int controlMode, int accelSamplesPerBatch, int accelBatchesPerSec, 214 int gyroSamplesPerBatch, int gyroBatchesPerSec, 215 int accelSamplesPerBatchHigh, int accelBatchesPerSecHigh, 216 int gyroSamplesPerBatchHigh, int gyroBatchesPerSecHigh, int algorithmConfig) 217 { 218 return mLocApi->setSensorPerfControlConfig(controlMode, accelSamplesPerBatch, accelBatchesPerSec, 219 gyroSamplesPerBatch, gyroBatchesPerSec, 220 accelSamplesPerBatchHigh, accelBatchesPerSecHigh, 221 gyroSamplesPerBatchHigh, gyroBatchesPerSecHigh, 222 algorithmConfig); 223 } 224 inline virtual enum loc_api_adapter_err setExtPowerConfig(int isBatteryCharging)225 setExtPowerConfig(int isBatteryCharging) 226 { 227 return mLocApi->setExtPowerConfig(isBatteryCharging); 228 } 229 inline virtual enum loc_api_adapter_err setAGLONASSProtocol(unsigned long aGlonassProtocol)230 setAGLONASSProtocol(unsigned long aGlonassProtocol) 231 { 232 return mLocApi->setAGLONASSProtocol(aGlonassProtocol); 233 } initDataServiceClient()234 inline virtual int initDataServiceClient() 235 { 236 return mLocApi->initDataServiceClient(); 237 } openAndStartDataCall()238 inline virtual int openAndStartDataCall() 239 { 240 return mLocApi->openAndStartDataCall(); 241 } stopDataCall()242 inline virtual void stopDataCall() 243 { 244 mLocApi->stopDataCall(); 245 } closeDataCall()246 inline virtual void closeDataCall() 247 { 248 mLocApi->closeDataCall(); 249 } 250 inline enum loc_api_adapter_err getZpp(GpsLocation & zppLoc,LocPosTechMask & tech_mask)251 getZpp(GpsLocation &zppLoc, LocPosTechMask &tech_mask) 252 { 253 return mLocApi->getBestAvailableZppFix(zppLoc, tech_mask); 254 } 255 enum loc_api_adapter_err setTime(GpsUtcTime time, 256 int64_t timeReference, 257 int uncertainty); 258 enum loc_api_adapter_err setXtraVersionCheck(int check); installAGpsCert(const DerEncodedCertificate * pData,size_t length,uint32_t slotBitMask)259 inline virtual void installAGpsCert(const DerEncodedCertificate* pData, 260 size_t length, 261 uint32_t slotBitMask) 262 { 263 mLocApi->installAGpsCert(pData, length, slotBitMask); 264 } 265 virtual void handleEngineDownEvent(); 266 virtual void handleEngineUpEvent(); 267 virtual void reportPosition(UlpLocation &location, 268 GpsLocationExtended &locationExtended, 269 void* locationExt, 270 enum loc_sess_status status, 271 LocPosTechMask loc_technology_mask); 272 virtual void reportSv(QtiGnssSvStatus &svStatus, 273 GpsLocationExtended &locationExtended, 274 void* svExt); 275 virtual void reportStatus(GpsStatusValue status); 276 virtual void reportNmea(const char* nmea, int length); 277 virtual bool reportXtraServer(const char* url1, const char* url2, 278 const char* url3, const int maxlength); 279 virtual bool requestXtraData(); 280 virtual bool requestTime(); 281 virtual bool requestATL(int connHandle, AGpsType agps_type); 282 virtual bool releaseATL(int connHandle); 283 virtual bool requestNiNotify(GpsNiNotification ¬ify, const void* data); 284 virtual bool requestSuplES(int connHandle); 285 virtual bool reportDataCallOpened(); 286 virtual bool reportDataCallClosed(); 287 virtual void reportGpsMeasurementData(GpsData &gpsMeasurementData); 288 getPositionMode()289 inline const LocPosMode& getPositionMode() const 290 {return mFixCriteria;} isInSession()291 inline virtual bool isInSession() 292 { return mNavigating; } 293 void setInSession(bool inSession); 294 295 // Permit/prohibit power voting setPowerVoteRight(bool powerVoteRight)296 inline void setPowerVoteRight(bool powerVoteRight) { 297 mPowerVote = powerVoteRight ? (mPowerVote | POWER_VOTE_RIGHT) : 298 (mPowerVote & ~POWER_VOTE_RIGHT); 299 } getPowerVoteRight()300 inline bool getPowerVoteRight() const { 301 return (mPowerVote & POWER_VOTE_RIGHT) != 0 ; 302 } 303 // Set the power voting up/down and do actual operation if permitted setPowerVote(bool powerOn)304 inline void setPowerVote(bool powerOn) { 305 mPowerVote = powerOn ? (mPowerVote | POWER_VOTE_VALUE) : 306 (mPowerVote & ~POWER_VOTE_VALUE); 307 requestPowerVote(); 308 mContext->modemPowerVote(powerOn); 309 } getPowerVote()310 inline bool getPowerVote() const { 311 return (mPowerVote & POWER_VOTE_VALUE) != 0 ; 312 } 313 // Do power voting according to last settings if permitted 314 void requestPowerVote(); 315 316 /*Values for lock 317 1 = Do not lock any position sessions 318 2 = Lock MI position sessions 319 3 = Lock MT position sessions 320 4 = Lock all position sessions 321 */ setGpsLock(LOC_GPS_LOCK_MASK lock)322 inline int setGpsLock(LOC_GPS_LOCK_MASK lock) 323 { 324 return mLocApi->setGpsLock(lock); 325 } 326 327 int setGpsLockMsg(LOC_GPS_LOCK_MASK lock); 328 329 /* 330 Returns 331 Current value of GPS lock on success 332 -1 on failure 333 */ getGpsLock()334 inline int getGpsLock() 335 { 336 return mLocApi->getGpsLock(); 337 } 338 339 /* 340 Update Registration Mask 341 */ 342 void updateRegistrationMask(LOC_API_ADAPTER_EVENT_MASK_T event, 343 loc_registration_mask_status isEnabled); 344 345 /* 346 Set Gnss Constellation Config 347 */ 348 bool gnssConstellationConfig(); 349 }; 350 351 #endif //LOC_API_ENG_ADAPTER_H 352