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 44using namespace loc_core; 45 46class LocEngAdapter; 47 48class LocInternalAdapter : public LocAdapterBase { 49 LocEngAdapter* mLocEngAdapter; 50public: 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 69typedef void (*loc_msg_sender)(void* loc_eng_data_p, void* msgp); 70 71class 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 84public: 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(); 96 inline void requestUlp(unsigned long capabilities) { 97 mContext->requestUlp(mInternalAdapter, capabilities); 98 } 99 inline LocInternalAdapter* getInternalAdapter() { return mInternalAdapter; } 100 inline UlpProxyBase* getUlpProxy() { return mUlp; } 101 inline void* getOwner() { return mOwner; } 102 inline bool hasAgpsExtendedCapabilities() { 103 return mContext->hasAgpsExtendedCapabilities(); 104 } 105 inline bool hasCPIExtendedCapabilities() { 106 return mContext->hasCPIExtendedCapabilities(); 107 } 108 inline const MsgTask* getMsgTask() { return mMsgTask; } 109 110 inline enum loc_api_adapter_err 111 startFix() 112 { 113 return mLocApi->startFix(mFixCriteria); 114 } 115 inline enum loc_api_adapter_err 116 stopFix() 117 { 118 return mLocApi->stopFix(); 119 } 120 inline enum loc_api_adapter_err 121 deleteAidingData(GpsAidingData f) 122 { 123 return mLocApi->deleteAidingData(f); 124 } 125 inline enum loc_api_adapter_err 126 enableData(int enable) 127 { 128 return mLocApi->enableData(enable); 129 } 130 inline enum loc_api_adapter_err 131 setAPN(char* apn, int len) 132 { 133 return mLocApi->setAPN(apn, len); 134 } 135 inline enum loc_api_adapter_err 136 injectPosition(double latitude, double longitude, float accuracy) 137 { 138 return mLocApi->injectPosition(latitude, longitude, accuracy); 139 } 140 inline enum loc_api_adapter_err 141 setXtraData(char* data, int length) 142 { 143 return mLocApi->setXtraData(data, length); 144 } 145 inline enum loc_api_adapter_err 146 requestXtraServer() 147 { 148 return mLocApi->requestXtraServer(); 149 } 150 inline enum loc_api_adapter_err 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 156 atlCloseStatus(int handle, int is_succ) 157 { 158 return mLocApi->atlCloseStatus(handle, is_succ); 159 } 160 inline enum loc_api_adapter_err 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 169 setServer(const char* url, int len) 170 { 171 return mLocApi->setServer(url, len); 172 } 173 inline enum loc_api_adapter_err 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 180 informNiResponse(GpsUserResponseType userResponse, const void* passThroughData) 181 { 182 return mLocApi->informNiResponse(userResponse, passThroughData); 183 } 184 inline enum loc_api_adapter_err 185 setSUPLVersion(uint32_t version) 186 { 187 return mLocApi->setSUPLVersion(version); 188 } 189 inline enum loc_api_adapter_err 190 setLPPConfig(uint32_t profile) 191 { 192 return mLocApi->setLPPConfig(profile); 193 } 194 inline enum loc_api_adapter_err 195 setSensorControlConfig(int sensorUsage, int sensorProvider) 196 { 197 return mLocApi->setSensorControlConfig(sensorUsage, sensorProvider); 198 } 199 inline enum loc_api_adapter_err 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 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 225 setExtPowerConfig(int isBatteryCharging) 226 { 227 return mLocApi->setExtPowerConfig(isBatteryCharging); 228 } 229 inline virtual enum loc_api_adapter_err 230 setAGLONASSProtocol(unsigned long aGlonassProtocol) 231 { 232 return mLocApi->setAGLONASSProtocol(aGlonassProtocol); 233 } 234 inline virtual int initDataServiceClient() 235 { 236 return mLocApi->initDataServiceClient(); 237 } 238 inline virtual int openAndStartDataCall() 239 { 240 return mLocApi->openAndStartDataCall(); 241 } 242 inline virtual void stopDataCall() 243 { 244 mLocApi->stopDataCall(); 245 } 246 inline virtual void closeDataCall() 247 { 248 mLocApi->closeDataCall(); 249 } 250 inline enum loc_api_adapter_err 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); 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 289 inline const LocPosMode& getPositionMode() const 290 {return mFixCriteria;} 291 inline virtual bool isInSession() 292 { return mNavigating; } 293 void setInSession(bool inSession); 294 295 // Permit/prohibit power voting 296 inline void setPowerVoteRight(bool powerVoteRight) { 297 mPowerVote = powerVoteRight ? (mPowerVote | POWER_VOTE_RIGHT) : 298 (mPowerVote & ~POWER_VOTE_RIGHT); 299 } 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 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 } 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 */ 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 */ 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