LocEngAdapter.h revision 2ec254f444925c654eca105d41fb8aaa52a34645 
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(QcomGnssSvStatus &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(QcomGnssSvStatus &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
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