1 /* Copyright (c) 2011-2016, 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(GnssSvStatus &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     GnssSystemInfo mGnssInfo;
89 
90     LocEngAdapter(LOC_API_ADAPTER_EVENT_MASK_T mask,
91                   void* owner, ContextBase* context,
92                   LocThread::tCreate tCreator);
93     virtual ~LocEngAdapter();
94 
95     virtual void setUlpProxy(UlpProxyBase* ulp);
96     void setXtraUserAgent();
requestUlp(unsigned long capabilities)97     inline void requestUlp(unsigned long capabilities) {
98         mContext->requestUlp(mInternalAdapter, capabilities);
99     }
getInternalAdapter()100     inline LocInternalAdapter* getInternalAdapter() { return mInternalAdapter; }
getUlpProxy()101     inline UlpProxyBase* getUlpProxy() { return mUlp; }
getOwner()102     inline void* getOwner() { return mOwner; }
hasAgpsExtendedCapabilities()103     inline bool hasAgpsExtendedCapabilities() {
104         return mContext->hasAgpsExtendedCapabilities();
105     }
hasCPIExtendedCapabilities()106     inline bool hasCPIExtendedCapabilities() {
107         return mContext->hasCPIExtendedCapabilities();
108     }
hasNativeXtraClient()109     inline bool hasNativeXtraClient() {
110         return mContext->hasNativeXtraClient();
111     }
getMsgTask()112     inline const MsgTask* getMsgTask() { return mMsgTask; }
113 
114     inline enum loc_api_adapter_err
startFix()115         startFix()
116     {
117         return mLocApi->startFix(mFixCriteria);
118     }
119     inline enum loc_api_adapter_err
stopFix()120         stopFix()
121     {
122         return mLocApi->stopFix();
123     }
124     inline enum loc_api_adapter_err
deleteAidingData(GpsAidingData f)125         deleteAidingData(GpsAidingData f)
126     {
127         return mLocApi->deleteAidingData(f);
128     }
129     inline enum loc_api_adapter_err
enableData(int enable)130         enableData(int enable)
131     {
132         return mLocApi->enableData(enable);
133     }
134     inline enum loc_api_adapter_err
setAPN(char * apn,int len)135         setAPN(char* apn, int len)
136     {
137         return mLocApi->setAPN(apn, len);
138     }
139     inline enum loc_api_adapter_err
injectPosition(double latitude,double longitude,float accuracy)140         injectPosition(double latitude, double longitude, float accuracy)
141     {
142         return mLocApi->injectPosition(latitude, longitude, accuracy);
143     }
144     inline enum loc_api_adapter_err
setXtraData(char * data,int length)145         setXtraData(char* data, int length)
146     {
147         return mLocApi->setXtraData(data, length);
148     }
149     inline enum loc_api_adapter_err
requestXtraServer()150         requestXtraServer()
151     {
152         return mLocApi->requestXtraServer();
153     }
154     inline enum loc_api_adapter_err
atlOpenStatus(int handle,int is_succ,char * apn,AGpsBearerType bearer,AGpsType agpsType)155         atlOpenStatus(int handle, int is_succ, char* apn, AGpsBearerType bearer, AGpsType agpsType)
156     {
157         return mLocApi->atlOpenStatus(handle, is_succ, apn, bearer, agpsType);
158     }
159     inline enum loc_api_adapter_err
atlCloseStatus(int handle,int is_succ)160         atlCloseStatus(int handle, int is_succ)
161     {
162         return mLocApi->atlCloseStatus(handle, is_succ);
163     }
164     inline enum loc_api_adapter_err
setPositionMode(const LocPosMode * posMode)165         setPositionMode(const LocPosMode *posMode)
166     {
167         if (NULL != posMode) {
168             mFixCriteria = *posMode;
169         }
170         return mLocApi->setPositionMode(mFixCriteria);
171     }
172     inline enum loc_api_adapter_err
setServer(const char * url,int len)173         setServer(const char* url, int len)
174     {
175         return mLocApi->setServer(url, len);
176     }
177     inline enum loc_api_adapter_err
setServer(unsigned int ip,int port,LocServerType type)178         setServer(unsigned int ip, int port,
179                   LocServerType type)
180     {
181         return mLocApi->setServer(ip, port, type);
182     }
183     inline enum loc_api_adapter_err
informNiResponse(GpsUserResponseType userResponse,const void * passThroughData)184         informNiResponse(GpsUserResponseType userResponse, const void* passThroughData)
185     {
186         return mLocApi->informNiResponse(userResponse, passThroughData);
187     }
188     inline enum loc_api_adapter_err
setSUPLVersion(uint32_t version)189         setSUPLVersion(uint32_t version)
190     {
191         return mLocApi->setSUPLVersion(version);
192     }
193     inline enum loc_api_adapter_err
setLPPConfig(uint32_t profile)194         setLPPConfig(uint32_t profile)
195     {
196         return mLocApi->setLPPConfig(profile);
197     }
198     inline enum loc_api_adapter_err
setSensorControlConfig(int sensorUsage,int sensorProvider)199         setSensorControlConfig(int sensorUsage, int sensorProvider)
200     {
201         return mLocApi->setSensorControlConfig(sensorUsage, sensorProvider);
202     }
203     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)204         setSensorProperties(bool gyroBiasVarianceRandomWalk_valid, float gyroBiasVarianceRandomWalk,
205                             bool accelBiasVarianceRandomWalk_valid, float accelBiasVarianceRandomWalk,
206                             bool angleBiasVarianceRandomWalk_valid, float angleBiasVarianceRandomWalk,
207                             bool rateBiasVarianceRandomWalk_valid, float rateBiasVarianceRandomWalk,
208                             bool velocityBiasVarianceRandomWalk_valid, float velocityBiasVarianceRandomWalk)
209     {
210         return mLocApi->setSensorProperties(gyroBiasVarianceRandomWalk_valid, gyroBiasVarianceRandomWalk,
211                                            accelBiasVarianceRandomWalk_valid, accelBiasVarianceRandomWalk,
212                                            angleBiasVarianceRandomWalk_valid, angleBiasVarianceRandomWalk,
213                                            rateBiasVarianceRandomWalk_valid, rateBiasVarianceRandomWalk,
214                                            velocityBiasVarianceRandomWalk_valid, velocityBiasVarianceRandomWalk);
215     }
216     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)217         setSensorPerfControlConfig(int controlMode, int accelSamplesPerBatch, int accelBatchesPerSec,
218                             int gyroSamplesPerBatch, int gyroBatchesPerSec,
219                             int accelSamplesPerBatchHigh, int accelBatchesPerSecHigh,
220                             int gyroSamplesPerBatchHigh, int gyroBatchesPerSecHigh, int algorithmConfig)
221     {
222         return mLocApi->setSensorPerfControlConfig(controlMode, accelSamplesPerBatch, accelBatchesPerSec,
223                                                   gyroSamplesPerBatch, gyroBatchesPerSec,
224                                                   accelSamplesPerBatchHigh, accelBatchesPerSecHigh,
225                                                   gyroSamplesPerBatchHigh, gyroBatchesPerSecHigh,
226                                                   algorithmConfig);
227     }
228     inline virtual enum loc_api_adapter_err
setExtPowerConfig(int isBatteryCharging)229         setExtPowerConfig(int isBatteryCharging)
230     {
231         return mLocApi->setExtPowerConfig(isBatteryCharging);
232     }
233     inline virtual enum loc_api_adapter_err
setAGLONASSProtocol(unsigned long aGlonassProtocol)234         setAGLONASSProtocol(unsigned long aGlonassProtocol)
235     {
236         return mLocApi->setAGLONASSProtocol(aGlonassProtocol);
237     }
initDataServiceClient()238     inline virtual int initDataServiceClient()
239     {
240         return mLocApi->initDataServiceClient();
241     }
openAndStartDataCall()242     inline virtual int openAndStartDataCall()
243     {
244         return mLocApi->openAndStartDataCall();
245     }
stopDataCall()246     inline virtual void stopDataCall()
247     {
248         mLocApi->stopDataCall();
249     }
closeDataCall()250     inline virtual void closeDataCall()
251     {
252         mLocApi->closeDataCall();
253     }
254     inline enum loc_api_adapter_err
getZpp(GpsLocation & zppLoc,LocPosTechMask & tech_mask)255         getZpp(GpsLocation &zppLoc, LocPosTechMask &tech_mask)
256     {
257         return mLocApi->getBestAvailableZppFix(zppLoc, tech_mask);
258     }
259     enum loc_api_adapter_err setTime(GpsUtcTime time,
260                                      int64_t timeReference,
261                                      int uncertainty);
262     enum loc_api_adapter_err setXtraVersionCheck(int check);
installAGpsCert(const DerEncodedCertificate * pData,size_t length,uint32_t slotBitMask)263     inline virtual void installAGpsCert(const DerEncodedCertificate* pData,
264                                         size_t length,
265                                         uint32_t slotBitMask)
266     {
267         mLocApi->installAGpsCert(pData, length, slotBitMask);
268     }
269     virtual void handleEngineDownEvent();
270     virtual void handleEngineUpEvent();
271     virtual void reportPosition(UlpLocation &location,
272                                 GpsLocationExtended &locationExtended,
273                                 void* locationExt,
274                                 enum loc_sess_status status,
275                                 LocPosTechMask loc_technology_mask);
276     virtual void reportSv(GnssSvStatus &svStatus,
277                           GpsLocationExtended &locationExtended,
278                           void* svExt);
279     virtual void reportStatus(GpsStatusValue status);
280     virtual void reportNmea(const char* nmea, int length);
281     virtual bool reportXtraServer(const char* url1, const char* url2,
282                                   const char* url3, const int maxlength);
283     virtual bool requestXtraData();
284     virtual bool requestTime();
285     virtual bool requestATL(int connHandle, AGpsType agps_type);
286     virtual bool releaseATL(int connHandle);
287     virtual bool requestNiNotify(GpsNiNotification &notify, const void* data);
288     virtual bool requestSuplES(int connHandle);
289     virtual bool reportDataCallOpened();
290     virtual bool reportDataCallClosed();
291     virtual void reportGnssMeasurementData(GnssData &gnssMeasurementData);
292 
getPositionMode()293     inline const LocPosMode& getPositionMode() const
294     {return mFixCriteria;}
isInSession()295     inline virtual bool isInSession()
296     { return mNavigating; }
297     void setInSession(bool inSession);
298 
299     // Permit/prohibit power voting
setPowerVoteRight(bool powerVoteRight)300     inline void setPowerVoteRight(bool powerVoteRight) {
301         mPowerVote = powerVoteRight ? (mPowerVote | POWER_VOTE_RIGHT) :
302                                       (mPowerVote & ~POWER_VOTE_RIGHT);
303     }
getPowerVoteRight()304     inline bool getPowerVoteRight() const {
305         return (mPowerVote & POWER_VOTE_RIGHT) != 0 ;
306     }
307     // Set the power voting up/down and do actual operation if permitted
setPowerVote(bool powerOn)308     inline void setPowerVote(bool powerOn) {
309         mPowerVote = powerOn ? (mPowerVote | POWER_VOTE_VALUE) :
310                                (mPowerVote & ~POWER_VOTE_VALUE);
311         requestPowerVote();
312         mContext->modemPowerVote(powerOn);
313     }
getPowerVote()314     inline bool getPowerVote() const {
315         return (mPowerVote & POWER_VOTE_VALUE) != 0 ;
316     }
317     // Do power voting according to last settings if permitted
318     void requestPowerVote();
319 
320     /*Values for lock
321       1 = Do not lock any position sessions
322       2 = Lock MI position sessions
323       3 = Lock MT position sessions
324       4 = Lock all position sessions
325     */
setGpsLock(LOC_GPS_LOCK_MASK lock)326     inline int setGpsLock(LOC_GPS_LOCK_MASK lock)
327     {
328         return mLocApi->setGpsLock(lock);
329     }
330 
331     int setGpsLockMsg(LOC_GPS_LOCK_MASK lock);
332 
333     /*
334       Returns
335       Current value of GPS lock on success
336       -1 on failure
337      */
getGpsLock()338     inline int getGpsLock()
339     {
340         return mLocApi->getGpsLock();
341     }
342 
343     /*
344       Update Registration Mask
345      */
346     void updateRegistrationMask(LOC_API_ADAPTER_EVENT_MASK_T event,
347                                 loc_registration_mask_status isEnabled);
348 
349     /*
350       Set Gnss Constellation Config
351      */
352     bool gnssConstellationConfig();
353 };
354 
355 #endif //LOC_API_ENG_ADAPTER_H
356