1 /* Copyright (c) 2011-2014, 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 #define LOG_NDDEBUG 0
30 #define LOG_TAG "LocSvc_LocApiBase"
31 
32 #include <dlfcn.h>
33 #include <LocApiBase.h>
34 #include <LocAdapterBase.h>
35 #include <log_util.h>
36 #include <LocDualContext.h>
37 
38 namespace loc_core {
39 
40 #define TO_ALL_LOCADAPTERS(call) TO_ALL_ADAPTERS(mLocAdapters, (call))
41 #define TO_1ST_HANDLING_LOCADAPTERS(call) TO_1ST_HANDLING_ADAPTER(mLocAdapters, (call))
42 
hexcode(char * hexstring,int string_size,const char * data,int data_size)43 int hexcode(char *hexstring, int string_size,
44             const char *data, int data_size)
45 {
46    int i;
47    for (i = 0; i < data_size; i++)
48    {
49       char ch = data[i];
50       if (i*2 + 3 <= string_size)
51       {
52          snprintf(&hexstring[i*2], 3, "%02X", ch);
53       }
54       else {
55          break;
56       }
57    }
58    return i;
59 }
60 
decodeAddress(char * addr_string,int string_size,const char * data,int data_size)61 int decodeAddress(char *addr_string, int string_size,
62                    const char *data, int data_size)
63 {
64     const char addr_prefix = 0x91;
65     int i, idxOutput = 0;
66 
67     if (!data || !addr_string) { return 0; }
68 
69     if (data[0] != addr_prefix)
70     {
71         LOC_LOGW("decodeAddress: address prefix is not 0x%x but 0x%x", addr_prefix, data[0]);
72         addr_string[0] = '\0';
73         return 0; // prefix not correct
74     }
75 
76     for (i = 1; i < data_size; i++)
77     {
78         unsigned char ch = data[i], low = ch & 0x0F, hi = ch >> 4;
79         if (low <= 9 && idxOutput < string_size - 1) { addr_string[idxOutput++] = low + '0'; }
80         if (hi <= 9 && idxOutput < string_size - 1) { addr_string[idxOutput++] = hi + '0'; }
81     }
82 
83     addr_string[idxOutput] = '\0'; // Terminates the string
84 
85     return idxOutput;
86 }
87 
88 struct LocSsrMsg : public LocMsg {
89     LocApiBase* mLocApi;
LocSsrMsgloc_core::LocSsrMsg90     inline LocSsrMsg(LocApiBase* locApi) :
91         LocMsg(), mLocApi(locApi)
92     {
93         locallog();
94     }
procloc_core::LocSsrMsg95     inline virtual void proc() const {
96         mLocApi->close();
97         mLocApi->open(mLocApi->getEvtMask());
98     }
locallogloc_core::LocSsrMsg99     inline void locallog() {
100         LOC_LOGV("LocSsrMsg");
101     }
logloc_core::LocSsrMsg102     inline virtual void log() {
103         locallog();
104     }
105 };
106 
107 struct LocOpenMsg : public LocMsg {
108     LocApiBase* mLocApi;
109     LOC_API_ADAPTER_EVENT_MASK_T mMask;
LocOpenMsgloc_core::LocOpenMsg110     inline LocOpenMsg(LocApiBase* locApi,
111                       LOC_API_ADAPTER_EVENT_MASK_T mask) :
112         LocMsg(), mLocApi(locApi), mMask(mask)
113     {
114         locallog();
115     }
procloc_core::LocOpenMsg116     inline virtual void proc() const {
117         mLocApi->open(mMask);
118     }
locallogloc_core::LocOpenMsg119     inline void locallog() {
120         LOC_LOGV("%s:%d]: LocOpen Mask: %x\n",
121                  __func__, __LINE__, mMask);
122     }
logloc_core::LocOpenMsg123     inline virtual void log() {
124         locallog();
125     }
126 };
127 
LocApiBase(const MsgTask * msgTask,LOC_API_ADAPTER_EVENT_MASK_T excludedMask,ContextBase * context)128 LocApiBase::LocApiBase(const MsgTask* msgTask,
129                        LOC_API_ADAPTER_EVENT_MASK_T excludedMask,
130                        ContextBase* context) :
131     mExcludedMask(excludedMask), mMsgTask(msgTask), mMask(0), mContext(context)
132 {
133     memset(mLocAdapters, 0, sizeof(mLocAdapters));
134 }
135 
getEvtMask()136 LOC_API_ADAPTER_EVENT_MASK_T LocApiBase::getEvtMask()
137 {
138     LOC_API_ADAPTER_EVENT_MASK_T mask = 0;
139 
140     TO_ALL_LOCADAPTERS(mask |= mLocAdapters[i]->getEvtMask());
141 
142     return mask & ~mExcludedMask;
143 }
144 
isInSession()145 bool LocApiBase::isInSession()
146 {
147     bool inSession = false;
148 
149     for (int i = 0;
150          !inSession && i < MAX_ADAPTERS && NULL != mLocAdapters[i];
151          i++) {
152         inSession = mLocAdapters[i]->isInSession();
153     }
154 
155     return inSession;
156 }
157 
addAdapter(LocAdapterBase * adapter)158 void LocApiBase::addAdapter(LocAdapterBase* adapter)
159 {
160     for (int i = 0; i < MAX_ADAPTERS && mLocAdapters[i] != adapter; i++) {
161         if (mLocAdapters[i] == NULL) {
162             mLocAdapters[i] = adapter;
163             mMsgTask->sendMsg(new LocOpenMsg(this,
164                                              (adapter->getEvtMask())));
165             break;
166         }
167     }
168 }
169 
removeAdapter(LocAdapterBase * adapter)170 void LocApiBase::removeAdapter(LocAdapterBase* adapter)
171 {
172     for (int i = 0;
173          i < MAX_ADAPTERS && NULL != mLocAdapters[i];
174          i++) {
175         if (mLocAdapters[i] == adapter) {
176             mLocAdapters[i] = NULL;
177 
178             // shift the rest of the adapters up so that the pointers
179             // in the array do not have holes.  This should be more
180             // performant, because the array maintenance is much much
181             // less frequent than event handlings, which need to linear
182             // search all the adapters
183             int j = i;
184             while (++i < MAX_ADAPTERS && mLocAdapters[i] != NULL);
185 
186             // i would be MAX_ADAPTERS or point to a NULL
187             i--;
188             // i now should point to a none NULL adapter within valid
189             // range although i could be equal to j, but it won't hurt.
190             // No need to check it, as it gains nothing.
191             mLocAdapters[j] = mLocAdapters[i];
192             // this makes sure that we exit the for loop
193             mLocAdapters[i] = NULL;
194 
195             // if we have an empty list of adapters
196             if (0 == i) {
197                 close();
198             } else {
199                 // else we need to remove the bit
200                 mMsgTask->sendMsg(new LocOpenMsg(this, getEvtMask()));
201             }
202         }
203     }
204 }
205 
handleEngineUpEvent()206 void LocApiBase::handleEngineUpEvent()
207 {
208     // This will take care of renegotiating the loc handle
209     mMsgTask->sendMsg(new LocSsrMsg(this));
210 
211     LocDualContext::injectFeatureConfig(mContext);
212 
213     // loop through adapters, and deliver to all adapters.
214     TO_ALL_LOCADAPTERS(mLocAdapters[i]->handleEngineUpEvent());
215 }
216 
handleEngineDownEvent()217 void LocApiBase::handleEngineDownEvent()
218 {
219     // loop through adapters, and deliver to all adapters.
220     TO_ALL_LOCADAPTERS(mLocAdapters[i]->handleEngineDownEvent());
221 }
222 
reportPosition(UlpLocation & location,GpsLocationExtended & locationExtended,void * locationExt,enum loc_sess_status status,LocPosTechMask loc_technology_mask)223 void LocApiBase::reportPosition(UlpLocation &location,
224                                 GpsLocationExtended &locationExtended,
225                                 void* locationExt,
226                                 enum loc_sess_status status,
227                                 LocPosTechMask loc_technology_mask)
228 {
229     // loop through adapters, and deliver to all adapters.
230     TO_ALL_LOCADAPTERS(
231         mLocAdapters[i]->reportPosition(location,
232                                         locationExtended,
233                                         locationExt,
234                                         status,
235                                         loc_technology_mask)
236     );
237 }
238 
reportSv(GpsSvStatus & svStatus,GpsLocationExtended & locationExtended,void * svExt)239 void LocApiBase::reportSv(GpsSvStatus &svStatus,
240                   GpsLocationExtended &locationExtended,
241                   void* svExt)
242 {
243     // loop through adapters, and deliver to all adapters.
244     TO_ALL_LOCADAPTERS(
245         mLocAdapters[i]->reportSv(svStatus,
246                                      locationExtended,
247                                      svExt)
248     );
249 }
250 
reportStatus(GpsStatusValue status)251 void LocApiBase::reportStatus(GpsStatusValue status)
252 {
253     // loop through adapters, and deliver to all adapters.
254     TO_ALL_LOCADAPTERS(mLocAdapters[i]->reportStatus(status));
255 }
256 
reportNmea(const char * nmea,int length)257 void LocApiBase::reportNmea(const char* nmea, int length)
258 {
259     // loop through adapters, and deliver to all adapters.
260     TO_ALL_LOCADAPTERS(mLocAdapters[i]->reportNmea(nmea, length));
261 }
262 
reportXtraServer(const char * url1,const char * url2,const char * url3,const int maxlength)263 void LocApiBase::reportXtraServer(const char* url1, const char* url2,
264                                   const char* url3, const int maxlength)
265 {
266     // loop through adapters, and deliver to the first handling adapter.
267     TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->reportXtraServer(url1, url2, url3, maxlength));
268 
269 }
270 
requestXtraData()271 void LocApiBase::requestXtraData()
272 {
273     // loop through adapters, and deliver to the first handling adapter.
274     TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->requestXtraData());
275 }
276 
requestTime()277 void LocApiBase::requestTime()
278 {
279     // loop through adapters, and deliver to the first handling adapter.
280     TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->requestTime());
281 }
282 
requestLocation()283 void LocApiBase::requestLocation()
284 {
285     // loop through adapters, and deliver to the first handling adapter.
286     TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->requestLocation());
287 }
288 
requestATL(int connHandle,AGpsType agps_type)289 void LocApiBase::requestATL(int connHandle, AGpsType agps_type)
290 {
291     // loop through adapters, and deliver to the first handling adapter.
292     TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->requestATL(connHandle, agps_type));
293 }
294 
releaseATL(int connHandle)295 void LocApiBase::releaseATL(int connHandle)
296 {
297     // loop through adapters, and deliver to the first handling adapter.
298     TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->releaseATL(connHandle));
299 }
300 
requestSuplES(int connHandle)301 void LocApiBase::requestSuplES(int connHandle)
302 {
303     // loop through adapters, and deliver to the first handling adapter.
304     TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->requestSuplES(connHandle));
305 }
306 
reportDataCallOpened()307 void LocApiBase::reportDataCallOpened()
308 {
309     // loop through adapters, and deliver to the first handling adapter.
310     TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->reportDataCallOpened());
311 }
312 
reportDataCallClosed()313 void LocApiBase::reportDataCallClosed()
314 {
315     // loop through adapters, and deliver to the first handling adapter.
316     TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->reportDataCallClosed());
317 }
318 
requestNiNotify(GpsNiNotification & notify,const void * data)319 void LocApiBase::requestNiNotify(GpsNiNotification &notify, const void* data)
320 {
321     // loop through adapters, and deliver to the first handling adapter.
322     TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->requestNiNotify(notify, data));
323 }
324 
getSibling()325 void* LocApiBase :: getSibling()
326     DEFAULT_IMPL(NULL)
327 
328 LocApiProxyBase* LocApiBase :: getLocApiProxy()
329     DEFAULT_IMPL(NULL)
330 
331 void LocApiBase::reportGpsMeasurementData(GpsData &gpsMeasurementData)
332 {
333     // loop through adapters, and deliver to all adapters.
334     TO_ALL_LOCADAPTERS(mLocAdapters[i]->reportGpsMeasurementData(gpsMeasurementData));
335 }
336 
337 enum loc_api_adapter_err LocApiBase::
338    open(LOC_API_ADAPTER_EVENT_MASK_T mask)
339 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
340 
341 enum loc_api_adapter_err LocApiBase::
342     close()
343 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
344 
345 enum loc_api_adapter_err LocApiBase::
346     startFix(const LocPosMode& posMode)
347 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
348 
349 enum loc_api_adapter_err LocApiBase::
350     stopFix()
351 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
352 
353 enum loc_api_adapter_err LocApiBase::
354     deleteAidingData(GpsAidingData f)
355 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
356 
357 enum loc_api_adapter_err LocApiBase::
358     enableData(int enable)
359 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
360 
361 enum loc_api_adapter_err LocApiBase::
362     setAPN(char* apn, int len)
363 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
364 
365 enum loc_api_adapter_err LocApiBase::
366     injectPosition(double latitude, double longitude, float accuracy)
367 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
368 
369 enum loc_api_adapter_err LocApiBase::
370     setTime(GpsUtcTime time, int64_t timeReference, int uncertainty)
371 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
372 
373 enum loc_api_adapter_err LocApiBase::
374     setXtraData(char* data, int length)
375 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
376 
377 enum loc_api_adapter_err LocApiBase::
378     requestXtraServer()
379 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
380 
381 enum loc_api_adapter_err LocApiBase::
382    atlOpenStatus(int handle, int is_succ, char* apn,
383                  AGpsBearerType bear, AGpsType agpsType)
384 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
385 
386 enum loc_api_adapter_err LocApiBase::
387     atlCloseStatus(int handle, int is_succ)
388 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
389 
390 enum loc_api_adapter_err LocApiBase::
391     setPositionMode(const LocPosMode& posMode)
392 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
393 
394 enum loc_api_adapter_err LocApiBase::
395     setServer(const char* url, int len)
396 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
397 
398 enum loc_api_adapter_err LocApiBase::
399     setServer(unsigned int ip, int port,
400               LocServerType type)
401 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
402 
403 enum loc_api_adapter_err LocApiBase::
404     informNiResponse(GpsUserResponseType userResponse,
405                      const void* passThroughData)
406 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
407 
408 enum loc_api_adapter_err LocApiBase::
409     setSUPLVersion(uint32_t version)
410 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
411 
412 enum loc_api_adapter_err LocApiBase::
413     setLPPConfig(uint32_t profile)
414 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
415 
416 enum loc_api_adapter_err LocApiBase::
417     setSensorControlConfig(int sensorUsage,
418                            int sensorProvider)
419 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
420 
421 enum loc_api_adapter_err LocApiBase::
422     setSensorProperties(bool gyroBiasVarianceRandomWalk_valid,
423                         float gyroBiasVarianceRandomWalk,
424                         bool accelBiasVarianceRandomWalk_valid,
425                         float accelBiasVarianceRandomWalk,
426                         bool angleBiasVarianceRandomWalk_valid,
427                         float angleBiasVarianceRandomWalk,
428                         bool rateBiasVarianceRandomWalk_valid,
429                         float rateBiasVarianceRandomWalk,
430                         bool velocityBiasVarianceRandomWalk_valid,
431                         float velocityBiasVarianceRandomWalk)
432 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
433 
434 enum loc_api_adapter_err LocApiBase::
435     setSensorPerfControlConfig(int controlMode,
436                                int accelSamplesPerBatch,
437                                int accelBatchesPerSec,
438                                int gyroSamplesPerBatch,
439                                int gyroBatchesPerSec,
440                                int accelSamplesPerBatchHigh,
441                                int accelBatchesPerSecHigh,
442                                int gyroSamplesPerBatchHigh,
443                                int gyroBatchesPerSecHigh,
444                                int algorithmConfig)
445 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
446 
447 enum loc_api_adapter_err LocApiBase::
448     setExtPowerConfig(int isBatteryCharging)
449 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
450 
451 enum loc_api_adapter_err LocApiBase::
452     setAGLONASSProtocol(unsigned long aGlonassProtocol)
453 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
454 
455 enum loc_api_adapter_err LocApiBase::
456    getWwanZppFix(GpsLocation & zppLoc)
457 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
458 
459 enum loc_api_adapter_err LocApiBase::
460    getBestAvailableZppFix(GpsLocation & zppLoc)
461 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
462 
463 enum loc_api_adapter_err LocApiBase::
464    getBestAvailableZppFix(GpsLocation & zppLoc, LocPosTechMask & tech_mask)
465 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
466 
467 int LocApiBase::
468     initDataServiceClient()
469 DEFAULT_IMPL(-1)
470 
471 int LocApiBase::
472     openAndStartDataCall()
473 DEFAULT_IMPL(-1)
474 
475 void LocApiBase::
476     stopDataCall()
477 DEFAULT_IMPL()
478 
479 void LocApiBase::
480     closeDataCall()
481 DEFAULT_IMPL()
482 
483 int LocApiBase::
484     setGpsLock(LOC_GPS_LOCK_MASK lock)
485 DEFAULT_IMPL(-1)
486 
487 void LocApiBase::
488     installAGpsCert(const DerEncodedCertificate* pData,
489                     size_t length,
490                     uint32_t slotBitMask)
491 DEFAULT_IMPL()
492 
493 int LocApiBase::
494     getGpsLock()
495 DEFAULT_IMPL(-1)
496 
497 int LocApiBase::
498     updateRegistrationMask(LOC_API_ADAPTER_EVENT_MASK_T event,
499                            loc_registration_mask_status isEnabled)
500 DEFAULT_IMPL(-1)
501 
502 bool LocApiBase::
503     gnssConstellationConfig()
504 DEFAULT_IMPL(false)
505 
506 } // namespace loc_core
507