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 &notify, 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