1 /* Copyright (c) 2009-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
30 #define LOG_NDDEBUG 0
31 #define LOG_TAG "LocSvc_eng"
32
33 #include <stdint.h>
34 #include <stdio.h>
35 #include <stdlib.h>
36 #include <unistd.h>
37 #include <dlfcn.h>
38 #include <ctype.h>
39 #include <math.h>
40 #include <pthread.h>
41 #include <arpa/inet.h>
42 #include <netinet/in.h> /* struct sockaddr_in */
43 #include <sys/socket.h>
44 #include <sys/time.h>
45 #include <netdb.h>
46 #include <time.h>
47 #include <new>
48 #include <LocEngAdapter.h>
49
50 #include <cutils/sched_policy.h>
51 #ifndef USE_GLIB
52 #include <utils/SystemClock.h>
53 #include <utils/Log.h>
54 #endif /* USE_GLIB */
55
56 #ifdef USE_GLIB
57 #include <glib.h>
58 #include <sys/syscall.h>
59 #endif /* USE_GLIB */
60
61 #include <string.h>
62
63 #include <loc_eng.h>
64 #include <loc_eng_ni.h>
65 #include <loc_eng_dmn_conn.h>
66 #include <loc_eng_dmn_conn_handler.h>
67 #include <loc_eng_msg.h>
68 #include <loc_eng_nmea.h>
69 #include <msg_q.h>
70 #include <loc.h>
71 #include "log_util.h"
72 #include "platform_lib_includes.h"
73 #include "loc_core_log.h"
74 #include "loc_eng_log.h"
75
76 #define SUCCESS TRUE
77 #define FAILURE FALSE
78
79 #ifndef GPS_CONF_FILE
80 #define GPS_CONF_FILE "/etc/gps.conf" //??? platform independent
81 #endif
82
83 #ifndef SAP_CONF_FILE
84 #define SAP_CONF_FILE "/etc/sap.conf"
85 #endif
86
87 #define XTRA1_GPSONEXTRA "xtra1.gpsonextra.net"
88
89 using namespace loc_core;
90
91 boolean configAlreadyRead = false;
92 unsigned int agpsStatus = 0;
93 loc_gps_cfg_s_type gps_conf;
94 loc_sap_cfg_s_type sap_conf;
95
96 /* Parameter spec table */
97 static loc_param_s_type gps_conf_table[] =
98 {
99 {"GPS_LOCK", &gps_conf.GPS_LOCK, NULL, 'n'},
100 {"SUPL_VER", &gps_conf.SUPL_VER, NULL, 'n'},
101 {"LPP_PROFILE", &gps_conf.LPP_PROFILE, NULL, 'n'},
102 {"A_GLONASS_POS_PROTOCOL_SELECT", &gps_conf.A_GLONASS_POS_PROTOCOL_SELECT, NULL, 'n'},
103 {"AGPS_CERT_WRITABLE_MASK", &gps_conf.AGPS_CERT_WRITABLE_MASK, NULL, 'n'},
104 {"INTERMEDIATE_POS", &gps_conf.INTERMEDIATE_POS, NULL, 'n'},
105 {"ACCURACY_THRES", &gps_conf.ACCURACY_THRES, NULL, 'n'},
106 {"NMEA_PROVIDER", &gps_conf.NMEA_PROVIDER, NULL, 'n'},
107 {"CAPABILITIES", &gps_conf.CAPABILITIES, NULL, 'n'},
108 };
109
110 static loc_param_s_type sap_conf_table[] =
111 {
112 {"GYRO_BIAS_RANDOM_WALK", &sap_conf.GYRO_BIAS_RANDOM_WALK, &sap_conf.GYRO_BIAS_RANDOM_WALK_VALID, 'f'},
113 {"ACCEL_RANDOM_WALK_SPECTRAL_DENSITY", &sap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY, &sap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY_VALID, 'f'},
114 {"ANGLE_RANDOM_WALK_SPECTRAL_DENSITY", &sap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY, &sap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY_VALID, 'f'},
115 {"RATE_RANDOM_WALK_SPECTRAL_DENSITY", &sap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY, &sap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY_VALID, 'f'},
116 {"VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY", &sap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY, &sap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY_VALID, 'f'},
117 {"SENSOR_ACCEL_BATCHES_PER_SEC", &sap_conf.SENSOR_ACCEL_BATCHES_PER_SEC, NULL, 'n'},
118 {"SENSOR_ACCEL_SAMPLES_PER_BATCH", &sap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH, NULL, 'n'},
119 {"SENSOR_GYRO_BATCHES_PER_SEC", &sap_conf.SENSOR_GYRO_BATCHES_PER_SEC, NULL, 'n'},
120 {"SENSOR_GYRO_SAMPLES_PER_BATCH", &sap_conf.SENSOR_GYRO_SAMPLES_PER_BATCH, NULL, 'n'},
121 {"SENSOR_ACCEL_BATCHES_PER_SEC_HIGH", &sap_conf.SENSOR_ACCEL_BATCHES_PER_SEC_HIGH, NULL, 'n'},
122 {"SENSOR_ACCEL_SAMPLES_PER_BATCH_HIGH", &sap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH_HIGH, NULL, 'n'},
123 {"SENSOR_GYRO_BATCHES_PER_SEC_HIGH", &sap_conf.SENSOR_GYRO_BATCHES_PER_SEC_HIGH, NULL, 'n'},
124 {"SENSOR_GYRO_SAMPLES_PER_BATCH_HIGH", &sap_conf.SENSOR_GYRO_SAMPLES_PER_BATCH_HIGH, NULL, 'n'},
125 {"SENSOR_CONTROL_MODE", &sap_conf.SENSOR_CONTROL_MODE, NULL, 'n'},
126 {"SENSOR_USAGE", &sap_conf.SENSOR_USAGE, NULL, 'n'},
127 {"SENSOR_ALGORITHM_CONFIG_MASK", &sap_conf.SENSOR_ALGORITHM_CONFIG_MASK, NULL, 'n'},
128 {"SENSOR_PROVIDER", &sap_conf.SENSOR_PROVIDER, NULL, 'n'},
129 {"XTRA_SERVER_1", &gps_conf.XTRA_SERVER_1, NULL, 's'},
130 {"XTRA_SERVER_2", &gps_conf.XTRA_SERVER_2, NULL, 's'},
131 {"XTRA_SERVER_3", &gps_conf.XTRA_SERVER_3, NULL, 's'}
132 };
133
loc_default_parameters(void)134 static void loc_default_parameters(void)
135 {
136 /* defaults */
137 gps_conf.INTERMEDIATE_POS = 0;
138 gps_conf.ACCURACY_THRES = 0;
139 gps_conf.NMEA_PROVIDER = 0;
140 gps_conf.GPS_LOCK = 0;
141 gps_conf.SUPL_VER = 0x10000;
142 gps_conf.CAPABILITIES = 0x7;
143
144 sap_conf.GYRO_BIAS_RANDOM_WALK = 0;
145 sap_conf.SENSOR_ACCEL_BATCHES_PER_SEC = 2;
146 sap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH = 5;
147 sap_conf.SENSOR_GYRO_BATCHES_PER_SEC = 2;
148 sap_conf.SENSOR_GYRO_SAMPLES_PER_BATCH = 5;
149 sap_conf.SENSOR_ACCEL_BATCHES_PER_SEC_HIGH = 4;
150 sap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH_HIGH = 25;
151 sap_conf.SENSOR_GYRO_BATCHES_PER_SEC_HIGH = 4;
152 sap_conf.SENSOR_GYRO_SAMPLES_PER_BATCH_HIGH = 25;
153 sap_conf.SENSOR_CONTROL_MODE = 0; /* AUTO */
154 sap_conf.SENSOR_USAGE = 0; /* Enabled */
155 sap_conf.SENSOR_ALGORITHM_CONFIG_MASK = 0; /* INS Disabled = FALSE*/
156
157 /* Values MUST be set by OEMs in configuration for sensor-assisted
158 navigation to work. There are NO default values */
159 sap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY = 0;
160 sap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY = 0;
161 sap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY = 0;
162 sap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY = 0;
163
164 sap_conf.GYRO_BIAS_RANDOM_WALK_VALID = 0;
165 sap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY_VALID = 0;
166 sap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY_VALID = 0;
167 sap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY_VALID = 0;
168 sap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY_VALID = 0;
169
170 /* LTE Positioning Profile configuration is disable by default*/
171 gps_conf.LPP_PROFILE = 0;
172
173 /*By default no positioning protocol is selected on A-GLONASS system*/
174 gps_conf.A_GLONASS_POS_PROTOCOL_SELECT = 0;
175
176 /* default provider is SSC */
177 sap_conf.SENSOR_PROVIDER = 1;
178
179 /* None of the 10 slots for agps certificates are writable by default */
180 gps_conf.AGPS_CERT_WRITABLE_MASK = 0;
181 }
182
183 // 2nd half of init(), singled out for
184 // modem restart to use.
185 static int loc_eng_reinit(loc_eng_data_s_type &loc_eng_data);
186 static void loc_eng_agps_reinit(loc_eng_data_s_type &loc_eng_data);
187
188 static int loc_eng_set_server(loc_eng_data_s_type &loc_eng_data,
189 LocServerType type, const char *hostname, int port);
190 // Internal functions
191 static void loc_inform_gps_status(loc_eng_data_s_type &loc_eng_data,
192 GpsStatusValue status);
193 static void loc_eng_report_status(loc_eng_data_s_type &loc_eng_data,
194 GpsStatusValue status);
195 static void loc_eng_process_conn_request(loc_eng_data_s_type &loc_eng_data,
196 int connHandle, AGpsType agps_type);
197 static void loc_eng_agps_close_status(loc_eng_data_s_type &loc_eng_data, int is_succ);
198 static void loc_eng_handle_engine_down(loc_eng_data_s_type &loc_eng_data) ;
199 static void loc_eng_handle_engine_up(loc_eng_data_s_type &loc_eng_data) ;
200
201 static int loc_eng_start_handler(loc_eng_data_s_type &loc_eng_data);
202 static int loc_eng_stop_handler(loc_eng_data_s_type &loc_eng_data);
203 static int loc_eng_get_zpp_handler(loc_eng_data_s_type &loc_eng_data);
204 static void loc_eng_handle_shutdown(loc_eng_data_s_type &loc_eng_data);
205 static void deleteAidingData(loc_eng_data_s_type &logEng);
206 static AgpsStateMachine*
207 getAgpsStateMachine(loc_eng_data_s_type& logEng, AGpsExtType agpsType);
208 static int dataCallCb(void *cb_data);
update_aiding_data_for_deletion(loc_eng_data_s_type & loc_eng_data)209 static void update_aiding_data_for_deletion(loc_eng_data_s_type& loc_eng_data) {
210 if (loc_eng_data.engine_status != GPS_STATUS_ENGINE_ON &&
211 loc_eng_data.aiding_data_for_deletion != 0)
212 {
213 loc_eng_data.adapter->deleteAidingData(loc_eng_data.aiding_data_for_deletion);
214 loc_eng_data.aiding_data_for_deletion = 0;
215 }
216 }
217
noProc(void * data)218 static void* noProc(void* data)
219 {
220 return NULL;
221 }
222
223
224 /*********************************************************************
225 * definitions of the static messages used in the file
226 *********************************************************************/
227 // case LOC_ENG_MSG_REQUEST_NI:
LocEngRequestNi(void * locEng,GpsNiNotification & notif,const void * data)228 LocEngRequestNi::LocEngRequestNi(void* locEng,
229 GpsNiNotification ¬if,
230 const void* data) :
231 LocMsg(), mLocEng(locEng), mNotify(notif), mPayload(data) {
232 locallog();
233 }
proc() const234 void LocEngRequestNi::proc() const {
235 loc_eng_ni_request_handler(*((loc_eng_data_s_type*)mLocEng),
236 &mNotify, mPayload);
237 }
locallog() const238 void LocEngRequestNi::locallog() const
239 {
240 LOC_LOGV("id: %d\n type: %s\n flags: %d\n time out: %d\n "
241 "default response: %s\n requestor id encoding: %s\n"
242 " text encoding: %s\n passThroughData: %p",
243 mNotify.notification_id,
244 loc_get_ni_type_name(mNotify.ni_type),
245 mNotify.notify_flags,
246 mNotify.timeout,
247 loc_get_ni_response_name(mNotify.default_response),
248 loc_get_ni_encoding_name(mNotify.requestor_id_encoding),
249 loc_get_ni_encoding_name(mNotify.text_encoding),
250 mPayload);
251 }
log() const252 inline void LocEngRequestNi::log() const {
253 locallog();
254 }
255
256 // case LOC_ENG_MSG_INFORM_NI_RESPONSE:
257 // in loc_eng_ni.cpp
258
259 // case LOC_ENG_MSG_START_FIX:
LocEngStartFix(LocEngAdapter * adapter)260 LocEngStartFix::LocEngStartFix(LocEngAdapter* adapter) :
261 LocMsg(), mAdapter(adapter)
262 {
263 locallog();
264 }
proc() const265 inline void LocEngStartFix::proc() const
266 {
267 loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mAdapter->getOwner();
268 loc_eng_start_handler(*locEng);
269 }
locallog() const270 inline void LocEngStartFix::locallog() const
271 {
272 LOC_LOGV("LocEngStartFix");
273 }
log() const274 inline void LocEngStartFix::log() const
275 {
276 locallog();
277 }
send() const278 void LocEngStartFix::send() const {
279 mAdapter->sendMsg(this);
280 }
281
282 // case LOC_ENG_MSG_STOP_FIX:
LocEngStopFix(LocEngAdapter * adapter)283 LocEngStopFix::LocEngStopFix(LocEngAdapter* adapter) :
284 LocMsg(), mAdapter(adapter)
285 {
286 locallog();
287 }
proc() const288 inline void LocEngStopFix::proc() const
289 {
290 loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mAdapter->getOwner();
291 loc_eng_stop_handler(*locEng);
292 }
locallog() const293 inline void LocEngStopFix::locallog() const
294 {
295 LOC_LOGV("LocEngStopFix");
296 }
log() const297 inline void LocEngStopFix::log() const
298 {
299 locallog();
300 }
send() const301 void LocEngStopFix::send() const {
302 mAdapter->sendMsg(this);
303 }
304
305 // case LOC_ENG_MSG_SET_POSITION_MODE:
LocEngPositionMode(LocEngAdapter * adapter,LocPosMode & mode)306 LocEngPositionMode::LocEngPositionMode(LocEngAdapter* adapter,
307 LocPosMode &mode) :
308 LocMsg(), mAdapter(adapter), mPosMode(mode)
309 {
310 mPosMode.logv();
311 }
proc() const312 inline void LocEngPositionMode::proc() const {
313 mAdapter->setPositionMode(&mPosMode);
314 }
log() const315 inline void LocEngPositionMode::log() const {
316 mPosMode.logv();
317 }
send() const318 void LocEngPositionMode::send() const {
319 mAdapter->sendMsg(this);
320 }
321
LocEngGetZpp(LocEngAdapter * adapter)322 LocEngGetZpp::LocEngGetZpp(LocEngAdapter* adapter) :
323 LocMsg(), mAdapter(adapter)
324 {
325 locallog();
326 }
proc() const327 inline void LocEngGetZpp::proc() const
328 {
329 loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mAdapter->getOwner();
330 loc_eng_get_zpp_handler(*locEng);
331 }
locallog() const332 inline void LocEngGetZpp::locallog() const
333 {
334 LOC_LOGV("LocEngGetZpp");
335 }
log() const336 inline void LocEngGetZpp::log() const
337 {
338 locallog();
339 }
send() const340 void LocEngGetZpp::send() const {
341 mAdapter->sendMsg(this);
342 }
343
344
LocEngShutdown(LocEngAdapter * adapter)345 LocEngShutdown::LocEngShutdown(LocEngAdapter* adapter) :
346 LocMsg(), mAdapter(adapter)
347 {
348 locallog();
349 }
proc() const350 inline void LocEngShutdown::proc() const
351 {
352 loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mAdapter->getOwner();
353 LOC_LOGD("%s:%d]: Calling loc_eng_handle_shutdown", __func__, __LINE__);
354 loc_eng_handle_shutdown(*locEng);
355 }
locallog() const356 inline void LocEngShutdown::locallog() const
357 {
358 LOC_LOGV("LocEngShutdown");
359 }
log() const360 inline void LocEngShutdown::log() const
361 {
362 locallog();
363 }
364
365 // case LOC_ENG_MSG_SET_TIME:
366 struct LocEngSetTime : public LocMsg {
367 LocEngAdapter* mAdapter;
368 const GpsUtcTime mTime;
369 const int64_t mTimeReference;
370 const int mUncertainty;
LocEngSetTimeLocEngSetTime371 inline LocEngSetTime(LocEngAdapter* adapter,
372 GpsUtcTime t, int64_t tf, int unc) :
373 LocMsg(), mAdapter(adapter),
374 mTime(t), mTimeReference(tf), mUncertainty(unc)
375 {
376 locallog();
377 }
procLocEngSetTime378 inline virtual void proc() const {
379 mAdapter->setTime(mTime, mTimeReference, mUncertainty);
380 }
locallogLocEngSetTime381 inline void locallog() const {
382 LOC_LOGV("time: %lld\n timeReference: %lld\n uncertainty: %d",
383 mTime, mTimeReference, mUncertainty);
384 }
logLocEngSetTime385 inline virtual void log() const {
386 locallog();
387 }
388 };
389
390 // case LOC_ENG_MSG_INJECT_LOCATION:
391 struct LocEngInjectLocation : public LocMsg {
392 LocEngAdapter* mAdapter;
393 const double mLatitude;
394 const double mLongitude;
395 const float mAccuracy;
LocEngInjectLocationLocEngInjectLocation396 inline LocEngInjectLocation(LocEngAdapter* adapter,
397 double lat, double lon, float accur) :
398 LocMsg(), mAdapter(adapter),
399 mLatitude(lat), mLongitude(lon), mAccuracy(accur)
400 {
401 locallog();
402 }
procLocEngInjectLocation403 inline virtual void proc() const {
404 mAdapter->injectPosition(mLatitude, mLongitude, mAccuracy);
405 }
locallogLocEngInjectLocation406 inline void locallog() const {
407 LOC_LOGV("latitude: %f\n longitude: %f\n accuracy: %f",
408 mLatitude, mLongitude, mAccuracy);
409 }
logLocEngInjectLocation410 inline virtual void log() const {
411 locallog();
412 }
413 };
414
415 // case LOC_ENG_MSG_SET_SERVER_IPV4:
416 struct LocEngSetServerIpv4 : public LocMsg {
417 LocEngAdapter* mAdapter;
418 const unsigned int mNlAddr;
419 const int mPort;
420 const LocServerType mServerType;
LocEngSetServerIpv4LocEngSetServerIpv4421 inline LocEngSetServerIpv4(LocEngAdapter* adapter,
422 unsigned int ip,
423 int port,
424 LocServerType type) :
425 LocMsg(), mAdapter(adapter),
426 mNlAddr(ip), mPort(port), mServerType(type)
427 {
428 locallog();
429 }
procLocEngSetServerIpv4430 inline virtual void proc() const {
431 mAdapter->setServer(mNlAddr, mPort, mServerType);
432 }
locallogLocEngSetServerIpv4433 inline void locallog() const {
434 LOC_LOGV("LocEngSetServerIpv4 - addr: %x, port: %d, type: %s",
435 mNlAddr, mPort, loc_get_server_type_name(mServerType));
436 }
logLocEngSetServerIpv4437 inline virtual void log() const {
438 locallog();
439 }
440 };
441
442 // case LOC_ENG_MSG_SET_SERVER_URL:
443 struct LocEngSetServerUrl : public LocMsg {
444 LocEngAdapter* mAdapter;
445 const int mLen;
446 char* mUrl;
LocEngSetServerUrlLocEngSetServerUrl447 inline LocEngSetServerUrl(LocEngAdapter* adapter,
448 char* urlString,
449 int url_len) :
450 LocMsg(), mAdapter(adapter),
451 mLen(url_len), mUrl(new char[mLen+1])
452 {
453 memcpy((void*)mUrl, (void*)urlString, url_len);
454 mUrl[mLen] = 0;
455 locallog();
456 }
~LocEngSetServerUrlLocEngSetServerUrl457 inline ~LocEngSetServerUrl()
458 {
459 delete[] mUrl;
460 }
procLocEngSetServerUrl461 inline virtual void proc() const {
462 mAdapter->setServer(mUrl, mLen);
463 }
locallogLocEngSetServerUrl464 inline void locallog() const {
465 LOC_LOGV("LocEngSetServerUrl - url: %s", mUrl);
466 }
logLocEngSetServerUrl467 inline virtual void log() const {
468 locallog();
469 }
470 };
471
472 // case LOC_ENG_MSG_A_GLONASS_PROTOCOL:
473 struct LocEngAGlonassProtocol : public LocMsg {
474 LocEngAdapter* mAdapter;
475 const unsigned long mAGlonassProtocl;
LocEngAGlonassProtocolLocEngAGlonassProtocol476 inline LocEngAGlonassProtocol(LocEngAdapter* adapter,
477 unsigned long protocol) :
478 LocMsg(), mAdapter(adapter), mAGlonassProtocl(protocol)
479 {
480 locallog();
481 }
procLocEngAGlonassProtocol482 inline virtual void proc() const {
483 mAdapter->setAGLONASSProtocol(mAGlonassProtocl);
484 }
locallogLocEngAGlonassProtocol485 inline void locallog() const {
486 LOC_LOGV("A-GLONASS protocol: 0x%lx", mAGlonassProtocl);
487 }
logLocEngAGlonassProtocol488 inline virtual void log() const {
489 locallog();
490 }
491 };
492
493 // case LOC_ENG_MSG_SUPL_VERSION:
494 struct LocEngSuplVer : public LocMsg {
495 LocEngAdapter* mAdapter;
496 const int mSuplVer;
LocEngSuplVerLocEngSuplVer497 inline LocEngSuplVer(LocEngAdapter* adapter,
498 int suplVer) :
499 LocMsg(), mAdapter(adapter), mSuplVer(suplVer)
500 {
501 locallog();
502 }
procLocEngSuplVer503 inline virtual void proc() const {
504 mAdapter->setSUPLVersion(mSuplVer);
505 }
locallogLocEngSuplVer506 inline void locallog() const {
507 LOC_LOGV("SUPL Version: %d", mSuplVer);
508 }
logLocEngSuplVer509 inline virtual void log() const {
510 locallog();
511 }
512 };
513
514 // case LOC_ENG_MSG_LPP_CONFIG:
515 struct LocEngLppConfig : public LocMsg {
516 LocEngAdapter* mAdapter;
517 const int mLppConfig;
LocEngLppConfigLocEngLppConfig518 inline LocEngLppConfig(LocEngAdapter* adapter,
519 int lppConfig) :
520 LocMsg(), mAdapter(adapter), mLppConfig(lppConfig)
521 {
522 locallog();
523 }
procLocEngLppConfig524 inline virtual void proc() const {
525 mAdapter->setLPPConfig(mLppConfig);
526 }
locallogLocEngLppConfig527 inline void locallog() const {
528 LOC_LOGV("LocEngLppConfig - profile: %d", mLppConfig);
529 }
logLocEngLppConfig530 inline virtual void log() const {
531 locallog();
532 }
533 };
534
535 // case LOC_ENG_MSG_SET_SENSOR_CONTROL_CONFIG:
536 struct LocEngSensorControlConfig : public LocMsg {
537 LocEngAdapter* mAdapter;
538 const int mSensorsDisabled;
539 const int mSensorProvider;
LocEngSensorControlConfigLocEngSensorControlConfig540 inline LocEngSensorControlConfig(LocEngAdapter* adapter,
541 int sensorsDisabled, int sensorProvider) :
542 LocMsg(), mAdapter(adapter), mSensorsDisabled(sensorsDisabled),
543 mSensorProvider(sensorProvider)
544 {
545 locallog();
546 }
procLocEngSensorControlConfig547 inline virtual void proc() const {
548 mAdapter->setSensorControlConfig(mSensorsDisabled, mSensorProvider);
549 }
locallogLocEngSensorControlConfig550 inline void locallog() const {
551 LOC_LOGV("LocEngSensorControlConfig - Sensors Disabled: %d, Sensor Provider: %d",
552 mSensorsDisabled, mSensorProvider);
553 }
logLocEngSensorControlConfig554 inline virtual void log() const {
555 locallog();
556 }
557 };
558
559 // case LOC_ENG_MSG_SET_SENSOR_PROPERTIES:
560 struct LocEngSensorProperties : public LocMsg {
561 LocEngAdapter* mAdapter;
562 const bool mGyroBiasVarianceRandomWalkValid;
563 const float mGyroBiasVarianceRandomWalk;
564 const bool mAccelRandomWalkValid;
565 const float mAccelRandomWalk;
566 const bool mAngleRandomWalkValid;
567 const float mAngleRandomWalk;
568 const bool mRateRandomWalkValid;
569 const float mRateRandomWalk;
570 const bool mVelocityRandomWalkValid;
571 const float mVelocityRandomWalk;
LocEngSensorPropertiesLocEngSensorProperties572 inline LocEngSensorProperties(LocEngAdapter* adapter,
573 bool gyroBiasRandomWalk_valid,
574 float gyroBiasRandomWalk,
575 bool accelRandomWalk_valid,
576 float accelRandomWalk,
577 bool angleRandomWalk_valid,
578 float angleRandomWalk,
579 bool rateRandomWalk_valid,
580 float rateRandomWalk,
581 bool velocityRandomWalk_valid,
582 float velocityRandomWalk) :
583 LocMsg(), mAdapter(adapter),
584 mGyroBiasVarianceRandomWalkValid(gyroBiasRandomWalk_valid),
585 mGyroBiasVarianceRandomWalk(gyroBiasRandomWalk),
586 mAccelRandomWalkValid(accelRandomWalk_valid),
587 mAccelRandomWalk(accelRandomWalk),
588 mAngleRandomWalkValid(angleRandomWalk_valid),
589 mAngleRandomWalk(angleRandomWalk),
590 mRateRandomWalkValid(rateRandomWalk_valid),
591 mRateRandomWalk(rateRandomWalk),
592 mVelocityRandomWalkValid(velocityRandomWalk_valid),
593 mVelocityRandomWalk(velocityRandomWalk)
594 {
595 locallog();
596 }
procLocEngSensorProperties597 inline virtual void proc() const {
598 mAdapter->setSensorProperties(mGyroBiasVarianceRandomWalkValid,
599 mGyroBiasVarianceRandomWalk,
600 mAccelRandomWalkValid,
601 mAccelRandomWalk,
602 mAngleRandomWalkValid,
603 mAngleRandomWalk,
604 mRateRandomWalkValid,
605 mRateRandomWalk,
606 mVelocityRandomWalkValid,
607 mVelocityRandomWalk);
608 }
locallogLocEngSensorProperties609 inline void locallog() const {
610 LOC_LOGV("Sensor properties validity, Gyro Random walk: %d "
611 "Accel Random Walk: %d "
612 "Angle Random Walk: %d Rate Random Walk: %d "
613 "Velocity Random Walk: %d\n"
614 "Sensor properties, Gyro Random walk: %f "
615 "Accel Random Walk: %f "
616 "Angle Random Walk: %f Rate Random Walk: %f "
617 "Velocity Random Walk: %f",
618 mGyroBiasVarianceRandomWalkValid,
619 mAccelRandomWalkValid,
620 mAngleRandomWalkValid,
621 mRateRandomWalkValid,
622 mVelocityRandomWalkValid,
623 mGyroBiasVarianceRandomWalk,
624 mAccelRandomWalk,
625 mAngleRandomWalk,
626 mRateRandomWalk,
627 mVelocityRandomWalk
628 );
629 }
logLocEngSensorProperties630 inline virtual void log() const {
631 locallog();
632 }
633 };
634
635 // case LOC_ENG_MSG_SET_SENSOR_PERF_CONTROL_CONFIG:
636 struct LocEngSensorPerfControlConfig : public LocMsg {
637 LocEngAdapter* mAdapter;
638 const int mControlMode;
639 const int mAccelSamplesPerBatch;
640 const int mAccelBatchesPerSec;
641 const int mGyroSamplesPerBatch;
642 const int mGyroBatchesPerSec;
643 const int mAccelSamplesPerBatchHigh;
644 const int mAccelBatchesPerSecHigh;
645 const int mGyroSamplesPerBatchHigh;
646 const int mGyroBatchesPerSecHigh;
647 const int mAlgorithmConfig;
LocEngSensorPerfControlConfigLocEngSensorPerfControlConfig648 inline LocEngSensorPerfControlConfig(LocEngAdapter* adapter,
649 int controlMode,
650 int accelSamplesPerBatch,
651 int accelBatchesPerSec,
652 int gyroSamplesPerBatch,
653 int gyroBatchesPerSec,
654 int accelSamplesPerBatchHigh,
655 int accelBatchesPerSecHigh,
656 int gyroSamplesPerBatchHigh,
657 int gyroBatchesPerSecHigh,
658 int algorithmConfig) :
659 LocMsg(), mAdapter(adapter),
660 mControlMode(controlMode),
661 mAccelSamplesPerBatch(accelSamplesPerBatch),
662 mAccelBatchesPerSec(accelBatchesPerSec),
663 mGyroSamplesPerBatch(gyroSamplesPerBatch),
664 mGyroBatchesPerSec(gyroBatchesPerSec),
665 mAccelSamplesPerBatchHigh(accelSamplesPerBatchHigh),
666 mAccelBatchesPerSecHigh(accelBatchesPerSecHigh),
667 mGyroSamplesPerBatchHigh(gyroSamplesPerBatchHigh),
668 mGyroBatchesPerSecHigh(gyroBatchesPerSecHigh),
669 mAlgorithmConfig(algorithmConfig)
670 {
671 locallog();
672 }
procLocEngSensorPerfControlConfig673 inline virtual void proc() const {
674 mAdapter->setSensorPerfControlConfig(mControlMode,
675 mAccelSamplesPerBatch,
676 mAccelBatchesPerSec,
677 mGyroSamplesPerBatch,
678 mGyroBatchesPerSec,
679 mAccelSamplesPerBatchHigh,
680 mAccelBatchesPerSecHigh,
681 mGyroSamplesPerBatchHigh,
682 mGyroBatchesPerSecHigh,
683 mAlgorithmConfig);
684 }
locallogLocEngSensorPerfControlConfig685 inline void locallog() const {
686 LOC_LOGV("Sensor Perf Control Config (performanceControlMode)(%u) "
687 "accel(#smp,#batches) (%u,%u) "
688 "gyro(#smp,#batches) (%u,%u), "
689 "accel_high(#smp,#batches) (%u,%u) "
690 "gyro_high(#smp,#batches) (%u,%u), "
691 "algorithmConfig(%u)\n",
692 mControlMode,
693 mAccelSamplesPerBatch, mAccelBatchesPerSec,
694 mGyroSamplesPerBatch, mGyroBatchesPerSec,
695 mAccelSamplesPerBatchHigh, mAccelBatchesPerSecHigh,
696 mGyroSamplesPerBatchHigh, mGyroBatchesPerSecHigh,
697 mAlgorithmConfig);
698 }
logLocEngSensorPerfControlConfig699 inline virtual void log() const {
700 locallog();
701 }
702 };
703
704 // case LOC_ENG_MSG_EXT_POWER_CONFIG:
705 struct LocEngExtPowerConfig : public LocMsg {
706 LocEngAdapter* mAdapter;
707 const int mIsBatteryCharging;
LocEngExtPowerConfigLocEngExtPowerConfig708 inline LocEngExtPowerConfig(LocEngAdapter* adapter,
709 int isBatteryCharging) :
710 LocMsg(), mAdapter(adapter),
711 mIsBatteryCharging(isBatteryCharging)
712 {
713 locallog();
714 }
procLocEngExtPowerConfig715 inline virtual void proc() const {
716 mAdapter->setExtPowerConfig(mIsBatteryCharging);
717 }
locallogLocEngExtPowerConfig718 inline void locallog() const {
719 LOC_LOGV("LocEngExtPowerConfig - isBatteryCharging: %d",
720 mIsBatteryCharging);
721 }
logLocEngExtPowerConfig722 inline virtual void log() const {
723 locallog();
724 }
725 };
726
727 // case LOC_ENG_MSG_REPORT_POSITION:
LocEngReportPosition(LocAdapterBase * adapter,UlpLocation & loc,GpsLocationExtended & locExtended,void * locExt,enum loc_sess_status st,LocPosTechMask technology)728 LocEngReportPosition::LocEngReportPosition(LocAdapterBase* adapter,
729 UlpLocation &loc,
730 GpsLocationExtended &locExtended,
731 void* locExt,
732 enum loc_sess_status st,
733 LocPosTechMask technology) :
734 LocMsg(), mAdapter(adapter), mLocation(loc),
735 mLocationExtended(locExtended),
736 mLocationExt(((loc_eng_data_s_type*)
737 ((LocEngAdapter*)
738 (mAdapter))->getOwner())->location_ext_parser(locExt)),
739 mStatus(st), mTechMask(technology)
740 {
741 locallog();
742 }
proc() const743 void LocEngReportPosition::proc() const {
744 LocEngAdapter* adapter = (LocEngAdapter*)mAdapter;
745 loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)adapter->getOwner();
746
747 if (locEng->mute_session_state != LOC_MUTE_SESS_IN_SESSION) {
748 bool reported = false;
749 if (locEng->location_cb != NULL) {
750 if (LOC_SESS_FAILURE == mStatus) {
751 // in case we want to handle the failure case
752 locEng->location_cb(NULL, NULL);
753 reported = true;
754 }
755 // what's in the else if is... (line by line)
756 // 1. this is a final fix; and
757 // 1.1 it is a Satellite fix; or
758 // 1.2 it is a sensor fix
759 // 2. (must be intermediate fix... implicit)
760 // 2.1 we accepte intermediate; and
761 // 2.2 it is NOT the case that
762 // 2.2.1 there is inaccuracy; and
763 // 2.2.2 we care about inaccuracy; and
764 // 2.2.3 the inaccuracy exceeds our tolerance
765 else if ((LOC_SESS_SUCCESS == mStatus &&
766 ((LOC_POS_TECH_MASK_SATELLITE |
767 LOC_POS_TECH_MASK_SENSORS |
768 LOC_POS_TECH_MASK_HYBRID) &
769 mTechMask)) ||
770 (LOC_SESS_INTERMEDIATE == locEng->intermediateFix &&
771 !((mLocation.gpsLocation.flags &
772 GPS_LOCATION_HAS_ACCURACY) &&
773 (gps_conf.ACCURACY_THRES != 0) &&
774 (mLocation.gpsLocation.accuracy >
775 gps_conf.ACCURACY_THRES)))) {
776 locEng->location_cb((UlpLocation*)&(mLocation),
777 (void*)mLocationExt);
778 reported = true;
779 }
780 }
781
782 // if we have reported this fix
783 if (reported &&
784 // and if this is a singleshot
785 GPS_POSITION_RECURRENCE_SINGLE ==
786 locEng->adapter->getPositionMode().recurrence) {
787 if (LOC_SESS_INTERMEDIATE == mStatus) {
788 // modem could be still working for a final fix,
789 // although we no longer need it. So stopFix().
790 locEng->adapter->stopFix();
791 }
792 // turn off the session flag.
793 locEng->adapter->setInSession(false);
794 }
795
796 if (locEng->generateNmea &&
797 mLocation.position_source == ULP_LOCATION_IS_FROM_GNSS &&
798 mTechMask & (LOC_POS_TECH_MASK_SATELLITE |
799 LOC_POS_TECH_MASK_SENSORS |
800 LOC_POS_TECH_MASK_HYBRID))
801 {
802 unsigned char generate_nmea = reported &&
803 (mStatus != LOC_SESS_FAILURE);
804 loc_eng_nmea_generate_pos(locEng, mLocation, mLocationExtended,
805 generate_nmea);
806 }
807
808 // Free the allocated memory for rawData
809 UlpLocation* gp = (UlpLocation*)&(mLocation);
810 if (gp != NULL && gp->rawData != NULL)
811 {
812 delete (char*)gp->rawData;
813 gp->rawData = NULL;
814 gp->rawDataSize = 0;
815 }
816 }
817 }
locallog() const818 void LocEngReportPosition::locallog() const {
819 LOC_LOGV("flags: %d\n source: %d\n latitude: %f\n longitude: %f\n "
820 "altitude: %f\n speed: %f\n bearing: %f\n accuracy: %f\n "
821 "timestamp: %lld\n rawDataSize: %d\n rawData: %p\n Session"
822 " status: %d\n Technology mask: %u",
823 mLocation.gpsLocation.flags, mLocation.position_source,
824 mLocation.gpsLocation.latitude, mLocation.gpsLocation.longitude,
825 mLocation.gpsLocation.altitude, mLocation.gpsLocation.speed,
826 mLocation.gpsLocation.bearing, mLocation.gpsLocation.accuracy,
827 mLocation.gpsLocation.timestamp, mLocation.rawDataSize,
828 mLocation.rawData, mStatus, mTechMask);
829 }
log() const830 void LocEngReportPosition::log() const {
831 locallog();
832 }
send() const833 void LocEngReportPosition::send() const {
834 mAdapter->sendMsg(this);
835 }
836
837
838 // case LOC_ENG_MSG_REPORT_SV:
LocEngReportSv(LocAdapterBase * adapter,GpsSvStatus & sv,GpsLocationExtended & locExtended,void * svExt)839 LocEngReportSv::LocEngReportSv(LocAdapterBase* adapter,
840 GpsSvStatus &sv,
841 GpsLocationExtended &locExtended,
842 void* svExt) :
843 LocMsg(), mAdapter(adapter), mSvStatus(sv),
844 mLocationExtended(locExtended),
845 mSvExt(((loc_eng_data_s_type*)
846 ((LocEngAdapter*)
847 (mAdapter))->getOwner())->sv_ext_parser(svExt))
848 {
849 locallog();
850 }
proc() const851 void LocEngReportSv::proc() const {
852 LocEngAdapter* adapter = (LocEngAdapter*)mAdapter;
853 loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)adapter->getOwner();
854
855 if (locEng->mute_session_state != LOC_MUTE_SESS_IN_SESSION)
856 {
857 if (locEng->sv_status_cb != NULL) {
858 locEng->sv_status_cb((GpsSvStatus*)&(mSvStatus),
859 (void*)mSvExt);
860 }
861
862 if (locEng->generateNmea)
863 {
864 loc_eng_nmea_generate_sv(locEng, mSvStatus, mLocationExtended);
865 }
866 }
867 }
locallog() const868 void LocEngReportSv::locallog() const {
869 LOC_LOGV("num sv: %d\n ephemeris mask: %dxn almanac mask: %x\n "
870 "used in fix mask: %x\n sv: prn snr "
871 "elevation azimuth",
872 mSvStatus.num_svs, mSvStatus.ephemeris_mask,
873 mSvStatus.almanac_mask, mSvStatus.used_in_fix_mask);
874 for (int i = 0; i < mSvStatus.num_svs && i < GPS_MAX_SVS; i++) {
875 LOC_LOGV(" %d: %d %f %f %f\n ",
876 i,
877 mSvStatus.sv_list[i].prn,
878 mSvStatus.sv_list[i].snr,
879 mSvStatus.sv_list[i].elevation,
880 mSvStatus.sv_list[i].azimuth);
881 }
882 }
log() const883 inline void LocEngReportSv::log() const {
884 locallog();
885 }
send() const886 void LocEngReportSv::send() const {
887 mAdapter->sendMsg(this);
888 }
889
890 // case LOC_ENG_MSG_REPORT_STATUS:
LocEngReportStatus(LocAdapterBase * adapter,GpsStatusValue engineStatus)891 LocEngReportStatus::LocEngReportStatus(LocAdapterBase* adapter,
892 GpsStatusValue engineStatus) :
893 LocMsg(), mAdapter(adapter), mStatus(engineStatus)
894 {
895 locallog();
896 }
proc() const897 inline void LocEngReportStatus::proc() const
898 {
899 LocEngAdapter* adapter = (LocEngAdapter*)mAdapter;
900 loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)adapter->getOwner();
901
902 loc_eng_report_status(*locEng, mStatus);
903 update_aiding_data_for_deletion(*locEng);
904 }
locallog() const905 inline void LocEngReportStatus::locallog() const {
906 LOC_LOGV("LocEngReportStatus");
907 }
log() const908 inline void LocEngReportStatus::log() const {
909 locallog();
910 }
911
912 // case LOC_ENG_MSG_REPORT_NMEA:
LocEngReportNmea(void * locEng,const char * data,int len)913 LocEngReportNmea::LocEngReportNmea(void* locEng,
914 const char* data, int len) :
915 LocMsg(), mLocEng(locEng), mNmea(new char[len]), mLen(len)
916 {
917 memcpy((void*)mNmea, (void*)data, len);
918 locallog();
919 }
proc() const920 void LocEngReportNmea::proc() const {
921 loc_eng_data_s_type* locEng = (loc_eng_data_s_type*) mLocEng;
922
923 struct timeval tv;
924 gettimeofday(&tv, (struct timezone *) NULL);
925 int64_t now = tv.tv_sec * 1000LL + tv.tv_usec / 1000;
926 CALLBACK_LOG_CALLFLOW("nmea_cb", %d, mLen);
927
928 if (locEng->nmea_cb != NULL)
929 locEng->nmea_cb(now, mNmea, mLen);
930 }
locallog() const931 inline void LocEngReportNmea::locallog() const {
932 LOC_LOGV("LocEngReportNmea");
933 }
log() const934 inline void LocEngReportNmea::log() const {
935 locallog();
936 }
937
938 // case LOC_ENG_MSG_REPORT_XTRA_SERVER:
LocEngReportXtraServer(void * locEng,const char * url1,const char * url2,const char * url3,const int maxlength)939 LocEngReportXtraServer::LocEngReportXtraServer(void* locEng,
940 const char *url1,
941 const char *url2,
942 const char *url3,
943 const int maxlength) :
944 LocMsg(), mLocEng(locEng), mMaxLen(maxlength),
945 mServers(new char[3*(mMaxLen+1)])
946 {
947 char * cptr = mServers;
948 memset(mServers, 0, 3*(mMaxLen+1));
949
950 // Override modem URLs with uncommented gps.conf urls
951 if( gps_conf.XTRA_SERVER_1[0] != '\0' ) {
952 url1 = &gps_conf.XTRA_SERVER_1[0];
953 }
954 if( gps_conf.XTRA_SERVER_2[0] != '\0' ) {
955 url2 = &gps_conf.XTRA_SERVER_2[0];
956 }
957 if( gps_conf.XTRA_SERVER_3[0] != '\0' ) {
958 url3 = &gps_conf.XTRA_SERVER_3[0];
959 }
960 // copy non xtra1.gpsonextra.net URLs into the forwarding buffer.
961 if( NULL == strcasestr(url1, XTRA1_GPSONEXTRA) ) {
962 strlcpy(cptr, url1, mMaxLen + 1);
963 cptr += mMaxLen + 1;
964 }
965 if( NULL == strcasestr(url2, XTRA1_GPSONEXTRA) ) {
966 strlcpy(cptr, url2, mMaxLen + 1);
967 cptr += mMaxLen + 1;
968 }
969 if( NULL == strcasestr(url3, XTRA1_GPSONEXTRA) ) {
970 strlcpy(cptr, url3, mMaxLen + 1);
971 }
972 locallog();
973 }
proc() const974 void LocEngReportXtraServer::proc() const {
975 loc_eng_xtra_data_s_type* locEngXtra =
976 &(((loc_eng_data_s_type*)mLocEng)->xtra_module_data);
977
978 if (locEngXtra->report_xtra_server_cb != NULL) {
979 CALLBACK_LOG_CALLFLOW("report_xtra_server_cb", %s, mServers);
980 locEngXtra->report_xtra_server_cb(mServers,
981 &(mServers[mMaxLen+1]),
982 &(mServers[(mMaxLen+1)<<1]));
983 } else {
984 LOC_LOGE("Callback function for request xtra is NULL");
985 }
986 }
locallog() const987 inline void LocEngReportXtraServer::locallog() const {
988 LOC_LOGV("LocEngReportXtraServers: server1: %s\n server2: %s\n"
989 " server3: %s\n",
990 mServers, &mServers[mMaxLen+1], &mServers[(mMaxLen+1)<<1]);
991 }
log() const992 inline void LocEngReportXtraServer::log() const {
993 locallog();
994 }
995
996 // case LOC_ENG_MSG_REQUEST_BIT:
997 // case LOC_ENG_MSG_RELEASE_BIT:
LocEngReqRelBIT(void * locEng,AGpsExtType type,int ipv4,char * ipv6,bool isReq)998 LocEngReqRelBIT::LocEngReqRelBIT(void* locEng, AGpsExtType type,
999 int ipv4, char* ipv6, bool isReq) :
1000 LocMsg(), mLocEng(locEng), mType(type), mIPv4Addr(ipv4),
1001 mIPv6Addr(ipv6 ? new char[16] : NULL), mIsReq(isReq) {
1002 if (NULL != ipv6)
1003 memcpy(mIPv6Addr, ipv6, 16);
1004 locallog();
1005 }
~LocEngReqRelBIT()1006 inline LocEngReqRelBIT::~LocEngReqRelBIT() {
1007 if (mIPv6Addr) {
1008 delete[] mIPv6Addr;
1009 }
1010 }
proc() const1011 void LocEngReqRelBIT::proc() const {
1012 loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
1013 BITSubscriber s(getAgpsStateMachine(*locEng, mType),
1014 mIPv4Addr, mIPv6Addr);
1015 AgpsStateMachine* sm = (AgpsStateMachine*)s.mStateMachine;
1016
1017 if (mIsReq) {
1018 sm->subscribeRsrc((Subscriber*)&s);
1019 } else {
1020 sm->unsubscribeRsrc((Subscriber*)&s);
1021 }
1022 }
locallog() const1023 inline void LocEngReqRelBIT::locallog() const {
1024 LOC_LOGV("LocEngRequestBIT - ipv4: %d.%d.%d.%d, ipv6: %s",
1025 (unsigned char)mIPv4Addr,
1026 (unsigned char)(mIPv4Addr>>8),
1027 (unsigned char)(mIPv4Addr>>16),
1028 (unsigned char)(mIPv4Addr>>24),
1029 NULL != mIPv6Addr ? mIPv6Addr : "");
1030 }
log() const1031 inline void LocEngReqRelBIT::log() const {
1032 locallog();
1033 }
send() const1034 void LocEngReqRelBIT::send() const {
1035 loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
1036 locEng->adapter->sendMsg(this);
1037 }
1038
1039 // case LOC_ENG_MSG_RELEASE_BIT:
1040 struct LocEngReleaseBIT : public LocMsg {
1041 const BITSubscriber mSubscriber;
LocEngReleaseBITLocEngReleaseBIT1042 inline LocEngReleaseBIT(const AgpsStateMachine* stateMachine,
1043 unsigned int ipv4, char* ipv6) :
1044 LocMsg(),
1045 mSubscriber(stateMachine, ipv4, ipv6)
1046 {
1047 locallog();
1048 }
procLocEngReleaseBIT1049 inline virtual void proc() const
1050 {
1051 AgpsStateMachine* sm = (AgpsStateMachine*)mSubscriber.mStateMachine;
1052 sm->unsubscribeRsrc((Subscriber*)&mSubscriber);
1053 }
locallogLocEngReleaseBIT1054 inline void locallog() const {
1055 LOC_LOGV("LocEngReleaseBIT - ipv4: %d.%d.%d.%d, ipv6: %s",
1056 (unsigned char)(mSubscriber.ID>>24),
1057 (unsigned char)(mSubscriber.ID>>16),
1058 (unsigned char)(mSubscriber.ID>>8),
1059 (unsigned char)mSubscriber.ID,
1060 NULL != mSubscriber.mIPv6Addr ? mSubscriber.mIPv6Addr : "");
1061 }
logLocEngReleaseBIT1062 virtual void log() const {
1063 locallog();
1064 }
1065 };
1066
1067 // LocEngSuplEsOpened
LocEngSuplEsOpened(void * locEng)1068 LocEngSuplEsOpened::LocEngSuplEsOpened(void* locEng) :
1069 LocMsg(), mLocEng(locEng) {
1070 locallog();
1071 }
proc() const1072 void LocEngSuplEsOpened::proc() const {
1073 loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
1074 if (locEng->ds_nif) {
1075 AgpsStateMachine* sm = locEng->ds_nif;
1076 sm->onRsrcEvent(RSRC_GRANTED);
1077 }
1078 }
locallog() const1079 void LocEngSuplEsOpened::locallog() const {
1080 LOC_LOGV("LocEngSuplEsOpened");
1081 }
log() const1082 void LocEngSuplEsOpened::log() const {
1083 locallog();
1084 }
1085
1086 // LocEngSuplEsClosed
LocEngSuplEsClosed(void * locEng)1087 LocEngSuplEsClosed::LocEngSuplEsClosed(void* locEng) :
1088 LocMsg(), mLocEng(locEng) {
1089 locallog();
1090 }
proc() const1091 void LocEngSuplEsClosed::proc() const {
1092 loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
1093 if (locEng->ds_nif) {
1094 AgpsStateMachine* sm = locEng->ds_nif;
1095 sm->onRsrcEvent(RSRC_RELEASED);
1096 }
1097 }
locallog() const1098 void LocEngSuplEsClosed::locallog() const {
1099 LOC_LOGV("LocEngSuplEsClosed");
1100 }
log() const1101 void LocEngSuplEsClosed::log() const {
1102 locallog();
1103 }
1104
1105
1106 // case LOC_ENG_MSG_REQUEST_SUPL_ES:
LocEngRequestSuplEs(void * locEng,int id)1107 LocEngRequestSuplEs::LocEngRequestSuplEs(void* locEng, int id) :
1108 LocMsg(), mLocEng(locEng), mID(id) {
1109 locallog();
1110 }
proc() const1111 void LocEngRequestSuplEs::proc() const {
1112 loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
1113 if (locEng->ds_nif) {
1114 AgpsStateMachine* sm = locEng->ds_nif;
1115 DSSubscriber s(sm, mID);
1116 sm->subscribeRsrc((Subscriber*)&s);
1117 } else {
1118 locEng->adapter->atlOpenStatus(mID, 0, NULL, -1, -1);
1119 }
1120 }
locallog() const1121 inline void LocEngRequestSuplEs::locallog() const {
1122 LOC_LOGV("LocEngRequestSuplEs");
1123 }
log() const1124 inline void LocEngRequestSuplEs::log() const {
1125 locallog();
1126 }
1127
1128 // case LOC_ENG_MSG_REQUEST_ATL:
LocEngRequestATL(void * locEng,int id,AGpsExtType agps_type)1129 LocEngRequestATL::LocEngRequestATL(void* locEng, int id,
1130 AGpsExtType agps_type) :
1131 LocMsg(), mLocEng(locEng), mID(id), mType(agps_type) {
1132 locallog();
1133 }
proc() const1134 void LocEngRequestATL::proc() const {
1135 loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
1136 AgpsStateMachine* sm = (AgpsStateMachine*)
1137 getAgpsStateMachine(*locEng, mType);
1138 if (sm) {
1139 ATLSubscriber s(mID,
1140 sm,
1141 locEng->adapter,
1142 AGPS_TYPE_INVALID == mType);
1143 sm->subscribeRsrc((Subscriber*)&s);
1144 } else {
1145 locEng->adapter->atlOpenStatus(mID, 0, NULL, -1, mType);
1146 }
1147 }
locallog() const1148 inline void LocEngRequestATL::locallog() const {
1149 LOC_LOGV("LocEngRequestATL");
1150 }
log() const1151 inline void LocEngRequestATL::log() const {
1152 locallog();
1153 }
1154
1155 // case LOC_ENG_MSG_RELEASE_ATL:
LocEngReleaseATL(void * locEng,int id)1156 LocEngReleaseATL::LocEngReleaseATL(void* locEng, int id) :
1157 LocMsg(), mLocEng(locEng), mID(id) {
1158 locallog();
1159 }
proc() const1160 void LocEngReleaseATL::proc() const {
1161 loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
1162
1163 if (locEng->agnss_nif) {
1164 ATLSubscriber s1(mID, locEng->agnss_nif, locEng->adapter, false);
1165 if (locEng->agnss_nif->unsubscribeRsrc((Subscriber*)&s1)) {
1166 LOC_LOGD("%s:%d]: Unsubscribed from agnss_nif",
1167 __func__, __LINE__);
1168 return;
1169 }
1170 }
1171
1172 if (locEng->internet_nif) {
1173 ATLSubscriber s2(mID, locEng->internet_nif, locEng->adapter, false);
1174 if (locEng->internet_nif->unsubscribeRsrc((Subscriber*)&s2)) {
1175 LOC_LOGD("%s:%d]: Unsubscribed from internet_nif",
1176 __func__, __LINE__);
1177 return;
1178 }
1179 }
1180
1181 if (locEng->ds_nif) {
1182 DSSubscriber s3(locEng->ds_nif, mID);
1183 if (locEng->ds_nif->unsubscribeRsrc((Subscriber*)&s3)) {
1184 LOC_LOGD("%s:%d]: Unsubscribed from ds_nif",
1185 __func__, __LINE__);
1186 return;
1187 }
1188 }
1189
1190 LOC_LOGW("%s:%d]: Could not release ATL. "
1191 "No subscribers found\n",
1192 __func__, __LINE__);
1193 locEng->adapter->atlCloseStatus(mID, 0);
1194 }
locallog() const1195 inline void LocEngReleaseATL::locallog() const {
1196 LOC_LOGV("LocEngReleaseATL");
1197 }
log() const1198 inline void LocEngReleaseATL::log() const {
1199 locallog();
1200 }
1201
1202 // case LOC_ENG_MSG_REQUEST_WIFI:
1203 // case LOC_ENG_MSG_RELEASE_WIFI:
LocEngReqRelWifi(void * locEng,AGpsExtType type,loc_if_req_sender_id_e_type sender_id,char * s,char * p,bool isReq)1204 LocEngReqRelWifi::LocEngReqRelWifi(void* locEng, AGpsExtType type,
1205 loc_if_req_sender_id_e_type sender_id,
1206 char* s, char* p, bool isReq) :
1207 LocMsg(), mLocEng(locEng), mType(type), mSenderId(sender_id),
1208 mSSID(NULL == s ? NULL : new char[SSID_BUF_SIZE]),
1209 mPassword(NULL == p ? NULL : new char[SSID_BUF_SIZE]),
1210 mIsReq(isReq) {
1211 if (NULL != s)
1212 strlcpy(mSSID, s, SSID_BUF_SIZE);
1213 if (NULL != p)
1214 strlcpy(mPassword, p, SSID_BUF_SIZE);
1215 locallog();
1216 }
~LocEngReqRelWifi()1217 LocEngReqRelWifi::~LocEngReqRelWifi() {
1218 if (NULL != mSSID) {
1219 delete[] mSSID;
1220 }
1221 if (NULL != mPassword) {
1222 delete[] mPassword;
1223 }
1224 }
proc() const1225 void LocEngReqRelWifi::proc() const {
1226 loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
1227 if (locEng->wifi_nif) {
1228 WIFISubscriber s(locEng->wifi_nif, mSSID, mPassword, mSenderId);
1229 if (mIsReq) {
1230 locEng->wifi_nif->subscribeRsrc((Subscriber*)&s);
1231 } else {
1232 locEng->wifi_nif->unsubscribeRsrc((Subscriber*)&s);
1233 }
1234 } else {
1235 locEng->adapter->atlOpenStatus(mSenderId, 0, NULL, -1, mType);
1236 }
1237 }
locallog() const1238 inline void LocEngReqRelWifi::locallog() const {
1239 LOC_LOGV("%s - senderId: %d, ssid: %s, password: %s",
1240 mIsReq ? "LocEngRequestWifi" : "LocEngReleaseWifi",
1241 mSenderId,
1242 NULL != mSSID ? mSSID : "",
1243 NULL != mPassword ? mPassword : "");
1244 }
log() const1245 inline void LocEngReqRelWifi::log() const {
1246 locallog();
1247 }
send() const1248 void LocEngReqRelWifi::send() const {
1249 loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
1250 locEng->adapter->sendMsg(this);
1251 }
1252
1253 // case LOC_ENG_MSG_REQUEST_XTRA_DATA:
LocEngRequestXtra(void * locEng)1254 LocEngRequestXtra::LocEngRequestXtra(void* locEng) :
1255 mLocEng(locEng) {
1256 locallog();
1257 }
proc() const1258 void LocEngRequestXtra::proc() const
1259 {
1260 loc_eng_xtra_data_s_type* locEngXtra =
1261 &(((loc_eng_data_s_type*)mLocEng)->xtra_module_data);
1262
1263 if (locEngXtra->download_request_cb != NULL) {
1264 CALLBACK_LOG_CALLFLOW("download_request_cb", %p, mLocEng);
1265 locEngXtra->download_request_cb();
1266 } else {
1267 LOC_LOGE("Callback function for request xtra is NULL");
1268 }
1269 }
locallog() const1270 inline void LocEngRequestXtra::locallog() const {
1271 LOC_LOGV("LocEngReqXtra");
1272 }
log() const1273 inline void LocEngRequestXtra::log() const {
1274 locallog();
1275 }
1276
1277 // case LOC_ENG_MSG_REQUEST_TIME:
LocEngRequestTime(void * locEng)1278 LocEngRequestTime::LocEngRequestTime(void* locEng) :
1279 LocMsg(), mLocEng(locEng)
1280 {
1281 locallog();
1282 }
proc() const1283 void LocEngRequestTime::proc() const {
1284 loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
1285 if (gps_conf.CAPABILITIES & GPS_CAPABILITY_ON_DEMAND_TIME) {
1286 if (locEng->request_utc_time_cb != NULL) {
1287 locEng->request_utc_time_cb();
1288 } else {
1289 LOC_LOGE("Callback function for request time is NULL");
1290 }
1291 }
1292 }
locallog() const1293 inline void LocEngRequestTime::locallog() const {
1294 LOC_LOGV("LocEngReqTime");
1295 }
log() const1296 inline void LocEngRequestTime::log() const {
1297 locallog();
1298 }
1299
1300 // case LOC_ENG_MSG_DELETE_AIDING_DATA:
1301 struct LocEngDelAidData : public LocMsg {
1302 loc_eng_data_s_type* mLocEng;
1303 const GpsAidingData mType;
LocEngDelAidDataLocEngDelAidData1304 inline LocEngDelAidData(loc_eng_data_s_type* locEng,
1305 GpsAidingData f) :
1306 LocMsg(), mLocEng(locEng), mType(f)
1307 {
1308 locallog();
1309 }
procLocEngDelAidData1310 inline virtual void proc() const {
1311 mLocEng->aiding_data_for_deletion = mType;
1312 update_aiding_data_for_deletion(*mLocEng);
1313 }
locallogLocEngDelAidData1314 inline void locallog() const {
1315 LOC_LOGV("aiding data msak %d", mType);
1316 }
logLocEngDelAidData1317 virtual void log() const {
1318 locallog();
1319 }
1320 };
1321
1322 // case LOC_ENG_MSG_ENABLE_DATA:
1323 struct LocEngEnableData : public LocMsg {
1324 LocEngAdapter* mAdapter;
1325 const int mEnable;
1326 char* mAPN;
1327 const int mLen;
LocEngEnableDataLocEngEnableData1328 inline LocEngEnableData(LocEngAdapter* adapter,
1329 const char* name, int len, int enable) :
1330 LocMsg(), mAdapter(adapter),
1331 mEnable(enable), mAPN(NULL), mLen(len)
1332 {
1333 if (NULL != name) {
1334 mAPN = new char[len+1];
1335 memcpy((void*)mAPN, (void*)name, len);
1336 mAPN[len] = 0;
1337 }
1338 locallog();
1339 }
~LocEngEnableDataLocEngEnableData1340 inline ~LocEngEnableData() {
1341 if (NULL != mAPN) {
1342 delete[] mAPN;
1343 }
1344 }
procLocEngEnableData1345 inline virtual void proc() const {
1346 mAdapter->enableData(mEnable);
1347 if (NULL != mAPN) {
1348 mAdapter->setAPN(mAPN, mLen);
1349 }
1350 }
locallogLocEngEnableData1351 inline void locallog() const {
1352 LOC_LOGV("apn: %s\n enable: %d",
1353 (NULL == mAPN) ? "NULL" : mAPN, mEnable);
1354 }
logLocEngEnableData1355 inline virtual void log() const {
1356 locallog();
1357 }
1358 };
1359
1360 // case LOC_ENG_MSG_INJECT_XTRA_DATA:
1361 // loc_eng_xtra.cpp
1362
1363 // case LOC_ENG_MSG_SET_CAPABILITIES:
1364 struct LocEngSetCapabilities : public LocMsg {
1365 loc_eng_data_s_type* mLocEng;
LocEngSetCapabilitiesLocEngSetCapabilities1366 inline LocEngSetCapabilities(loc_eng_data_s_type* locEng) :
1367 LocMsg(), mLocEng(locEng)
1368 {
1369 locallog();
1370 }
procLocEngSetCapabilities1371 inline virtual void proc() const {
1372 if (NULL != mLocEng->set_capabilities_cb) {
1373 LOC_LOGV("calling set_capabilities_cb 0x%x",
1374 gps_conf.CAPABILITIES);
1375 mLocEng->set_capabilities_cb(gps_conf.CAPABILITIES);
1376 } else {
1377 LOC_LOGV("set_capabilities_cb is NULL.\n");
1378 }
1379 }
locallogLocEngSetCapabilities1380 inline void locallog() const
1381 {
1382 LOC_LOGV("LocEngSetCapabilities");
1383 }
logLocEngSetCapabilities1384 inline virtual void log() const
1385 {
1386 locallog();
1387 }
1388 };
1389
1390 // case LOC_ENG_MSG_LOC_INIT:
1391 struct LocEngInit : public LocMsg {
1392 loc_eng_data_s_type* mLocEng;
LocEngInitLocEngInit1393 inline LocEngInit(loc_eng_data_s_type* locEng) :
1394 LocMsg(), mLocEng(locEng)
1395 {
1396 locallog();
1397 }
procLocEngInit1398 inline virtual void proc() const {
1399 loc_eng_reinit(*mLocEng);
1400 // set the capabilities
1401 mLocEng->adapter->sendMsg(new LocEngSetCapabilities(mLocEng));
1402 }
locallogLocEngInit1403 inline void locallog() const
1404 {
1405 LOC_LOGV("LocEngInit");
1406 }
logLocEngInit1407 inline virtual void log() const
1408 {
1409 locallog();
1410 }
1411 };
1412
1413 // case LOC_ENG_MSG_REQUEST_XTRA_SERVER:
1414 // loc_eng_xtra.cpp
1415
1416 // case LOC_ENG_MSG_ATL_OPEN_SUCCESS:
1417 struct LocEngAtlOpenSuccess : public LocMsg {
1418 AgpsStateMachine* mStateMachine;
1419 const int mLen;
1420 char* mAPN;
1421 const AGpsBearerType mBearerType;
LocEngAtlOpenSuccessLocEngAtlOpenSuccess1422 inline LocEngAtlOpenSuccess(AgpsStateMachine* statemachine,
1423 const char* name,
1424 int len,
1425 AGpsBearerType btype) :
1426 LocMsg(),
1427 mStateMachine(statemachine), mLen(len),
1428 mAPN(new char[len+1]), mBearerType(btype)
1429 {
1430 memcpy((void*)mAPN, (void*)name, len);
1431 mAPN[len] = 0;
1432 locallog();
1433 }
~LocEngAtlOpenSuccessLocEngAtlOpenSuccess1434 inline ~LocEngAtlOpenSuccess()
1435 {
1436 delete[] mAPN;
1437 }
procLocEngAtlOpenSuccess1438 inline virtual void proc() const {
1439 mStateMachine->setBearer(mBearerType);
1440 mStateMachine->setAPN(mAPN, mLen);
1441 mStateMachine->onRsrcEvent(RSRC_GRANTED);
1442 }
locallogLocEngAtlOpenSuccess1443 inline void locallog() const {
1444 LOC_LOGV("LocEngAtlOpenSuccess agps type: %s\n apn: %s\n"
1445 " bearer type: %s",
1446 loc_get_agps_type_name(mStateMachine->getType()),
1447 mAPN,
1448 loc_get_agps_bear_name(mBearerType));
1449 }
logLocEngAtlOpenSuccess1450 inline virtual void log() const {
1451 locallog();
1452 }
1453 };
1454
1455 // case LOC_ENG_MSG_ATL_CLOSED:
1456 struct LocEngAtlClosed : public LocMsg {
1457 AgpsStateMachine* mStateMachine;
LocEngAtlClosedLocEngAtlClosed1458 inline LocEngAtlClosed(AgpsStateMachine* statemachine) :
1459 LocMsg(), mStateMachine(statemachine) {
1460 locallog();
1461 }
procLocEngAtlClosed1462 inline virtual void proc() const {
1463 mStateMachine->onRsrcEvent(RSRC_RELEASED);
1464 }
locallogLocEngAtlClosed1465 inline void locallog() const {
1466 LOC_LOGV("LocEngAtlClosed");
1467 }
logLocEngAtlClosed1468 inline virtual void log() const {
1469 locallog();
1470 }
1471 };
1472
1473 // case LOC_ENG_MSG_ATL_OPEN_FAILED:
1474 struct LocEngAtlOpenFailed : public LocMsg {
1475 AgpsStateMachine* mStateMachine;
LocEngAtlOpenFailedLocEngAtlOpenFailed1476 inline LocEngAtlOpenFailed(AgpsStateMachine* statemachine) :
1477 LocMsg(), mStateMachine(statemachine) {
1478 locallog();
1479 }
procLocEngAtlOpenFailed1480 inline virtual void proc() const {
1481 mStateMachine->onRsrcEvent(RSRC_DENIED);
1482 }
locallogLocEngAtlOpenFailed1483 inline void locallog() const {
1484 LOC_LOGV("LocEngAtlOpenFailed");
1485 }
logLocEngAtlOpenFailed1486 inline virtual void log() const {
1487 locallog();
1488 }
1489 };
1490
1491 // case LOC_ENG_MSG_ENGINE_DOWN:
LocEngDown(void * locEng)1492 LocEngDown::LocEngDown(void* locEng) :
1493 LocMsg(), mLocEng(locEng) {
1494 locallog();
1495 }
proc() const1496 inline void LocEngDown::proc() const {
1497 loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
1498 loc_eng_handle_engine_down(*locEng);
1499 }
locallog() const1500 inline void LocEngDown::locallog() const {
1501 LOC_LOGV("LocEngDown");
1502 }
log() const1503 inline void LocEngDown::log() const {
1504 locallog();
1505 }
1506
1507 // case LOC_ENG_MSG_ENGINE_UP:
LocEngUp(void * locEng)1508 LocEngUp::LocEngUp(void* locEng) :
1509 LocMsg(), mLocEng(locEng) {
1510 locallog();
1511 }
proc() const1512 inline void LocEngUp::proc() const {
1513 loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
1514 loc_eng_handle_engine_up(*locEng);
1515 }
locallog() const1516 inline void LocEngUp::locallog() const {
1517 LOC_LOGV("LocEngUp");
1518 }
log() const1519 inline void LocEngUp::log() const {
1520 locallog();
1521 }
1522
1523 struct LocEngDataClientInit : public LocMsg {
1524 loc_eng_data_s_type* mLocEng;
LocEngDataClientInitLocEngDataClientInit1525 inline LocEngDataClientInit(loc_eng_data_s_type* locEng) :
1526 LocMsg(), mLocEng(locEng) {
1527 locallog();
1528 }
procLocEngDataClientInit1529 virtual void proc() const {
1530 loc_eng_data_s_type *locEng = (loc_eng_data_s_type *)mLocEng;
1531 if(!locEng->adapter->initDataServiceClient()) {
1532 locEng->ds_nif = new DSStateMachine(servicerTypeExt,
1533 (void *)dataCallCb,
1534 locEng->adapter);
1535 }
1536 }
locallogLocEngDataClientInit1537 void locallog() const {
1538 LOC_LOGV("LocEngDataClientInit\n");
1539 }
logLocEngDataClientInit1540 virtual void log() const {
1541 locallog();
1542 }
1543 };
1544
1545 struct LocEngInstallAGpsCert : public LocMsg {
1546 LocEngAdapter* mpAdapter;
1547 const size_t mNumberOfCerts;
1548 const uint32_t mSlotBitMask;
1549 DerEncodedCertificate* mpData;
LocEngInstallAGpsCertLocEngInstallAGpsCert1550 inline LocEngInstallAGpsCert(LocEngAdapter* adapter,
1551 const DerEncodedCertificate* pData,
1552 size_t numberOfCerts,
1553 uint32_t slotBitMask) :
1554 LocMsg(), mpAdapter(adapter),
1555 mNumberOfCerts(numberOfCerts), mSlotBitMask(slotBitMask),
1556 mpData(new DerEncodedCertificate[mNumberOfCerts])
1557 {
1558 for (int i=0; i < mNumberOfCerts; i++) {
1559 mpData[i].data = new u_char[pData[i].length];
1560 if (mpData[i].data) {
1561 memcpy(mpData[i].data, (void*)pData[i].data, pData[i].length);
1562 mpData[i].length = pData[i].length;
1563 } else {
1564 LOC_LOGE("malloc failed for cert#%d", i);
1565 break;
1566 }
1567 }
1568 locallog();
1569 }
~LocEngInstallAGpsCertLocEngInstallAGpsCert1570 inline ~LocEngInstallAGpsCert()
1571 {
1572 for (int i=0; i < mNumberOfCerts; i++) {
1573 if (mpData[i].data) {
1574 delete[] mpData[i].data;
1575 }
1576 }
1577 delete[] mpData;
1578 }
procLocEngInstallAGpsCert1579 inline virtual void proc() const {
1580 mpAdapter->installAGpsCert(mpData, mNumberOfCerts, mSlotBitMask);
1581 }
locallogLocEngInstallAGpsCert1582 inline void locallog() const {
1583 LOC_LOGV("LocEngInstallAGpsCert - certs=%u mask=%u",
1584 mNumberOfCerts, mSlotBitMask);
1585 }
logLocEngInstallAGpsCert1586 inline virtual void log() const {
1587 locallog();
1588 }
1589 };
1590
1591 struct LocEngUpdateRegistrationMask : public LocMsg {
1592 loc_eng_data_s_type* mLocEng;
1593 LOC_API_ADAPTER_EVENT_MASK_T mMask;
1594 loc_registration_mask_status mIsEnabled;
LocEngUpdateRegistrationMaskLocEngUpdateRegistrationMask1595 inline LocEngUpdateRegistrationMask(loc_eng_data_s_type* locEng,
1596 LOC_API_ADAPTER_EVENT_MASK_T mask,
1597 loc_registration_mask_status isEnabled) :
1598 LocMsg(), mLocEng(locEng), mMask(mask), mIsEnabled(isEnabled) {
1599 locallog();
1600 }
procLocEngUpdateRegistrationMask1601 inline virtual void proc() const {
1602 loc_eng_data_s_type *locEng = (loc_eng_data_s_type *)mLocEng;
1603 locEng->adapter->updateRegistrationMask(mMask,
1604 mIsEnabled);
1605 }
locallogLocEngUpdateRegistrationMask1606 void locallog() const {
1607 LOC_LOGV("LocEngUpdateRegistrationMask\n");
1608 }
logLocEngUpdateRegistrationMask1609 virtual void log() const {
1610 locallog();
1611 }
1612 };
1613
1614 struct LocEngGnssConstellationConfig : public LocMsg {
1615 LocEngAdapter* mAdapter;
LocEngGnssConstellationConfigLocEngGnssConstellationConfig1616 inline LocEngGnssConstellationConfig(LocEngAdapter* adapter) :
1617 LocMsg(), mAdapter(adapter) {
1618 locallog();
1619 }
procLocEngGnssConstellationConfig1620 inline virtual void proc() const {
1621 if (mAdapter->gnssConstellationConfig()) {
1622 LOC_LOGV("Modem supports GNSS measurements\n");
1623 gps_conf.CAPABILITIES |= GPS_CAPABILITY_MEASUREMENTS;
1624 } else {
1625 LOC_LOGV("Modem does not support GNSS measurements\n");
1626 }
1627 }
locallogLocEngGnssConstellationConfig1628 void locallog() const {
1629 LOC_LOGV("LocEngGnssConstellationConfig\n");
1630 }
logLocEngGnssConstellationConfig1631 virtual void log() const {
1632 locallog();
1633 }
1634 };
1635
1636 // case LOC_ENG_MSG_REPORT_GNSS_MEASUREMENT:
LocEngReportGpsMeasurement(void * locEng,GpsData & gpsData)1637 LocEngReportGpsMeasurement::LocEngReportGpsMeasurement(void* locEng,
1638 GpsData &gpsData) :
1639 LocMsg(), mLocEng(locEng), mGpsData(gpsData)
1640 {
1641 locallog();
1642 }
proc() const1643 void LocEngReportGpsMeasurement::proc() const {
1644 loc_eng_data_s_type* locEng = (loc_eng_data_s_type*) mLocEng;
1645 if (locEng->mute_session_state != LOC_MUTE_SESS_IN_SESSION)
1646 {
1647 if (locEng->gps_measurement_cb != NULL) {
1648 locEng->gps_measurement_cb((GpsData*)&(mGpsData));
1649 }
1650 }
1651 }
locallog() const1652 void LocEngReportGpsMeasurement::locallog() const {
1653 IF_LOC_LOGV {
1654 LOC_LOGV("%s:%d]: Received in GPS HAL."
1655 "GNSS Measurements count: %d \n",
1656 __func__, __LINE__, mGpsData.measurement_count);
1657 for (int i =0; i< mGpsData.measurement_count && i < GPS_MAX_SVS; i++) {
1658 LOC_LOGV(" GNSS measurement data in GPS HAL: \n"
1659 " GPS_HAL => Measurement ID | prn | time_offset_ns | state |"
1660 " received_gps_tow_ns| c_n0_dbhz | pseudorange_rate_mps |"
1661 " pseudorange_rate_uncertainty_mps |"
1662 " accumulated_delta_range_state | flags \n"
1663 " GPS_HAL => %d | %d | %f | %d | %lld | %f | %f | %f | %d | %d \n",
1664 i,
1665 mGpsData.measurements[i].prn,
1666 mGpsData.measurements[i].time_offset_ns,
1667 mGpsData.measurements[i].state,
1668 mGpsData.measurements[i].received_gps_tow_ns,
1669 mGpsData.measurements[i].c_n0_dbhz,
1670 mGpsData.measurements[i].pseudorange_rate_mps,
1671 mGpsData.measurements[i].pseudorange_rate_uncertainty_mps,
1672 mGpsData.measurements[i].accumulated_delta_range_state,
1673 mGpsData.measurements[i].flags);
1674 }
1675 LOC_LOGV(" GPS_HAL => Clocks Info: type | time_ns \n"
1676 " GPS_HAL => Clocks Info: %d | %lld", mGpsData.clock.type,
1677 mGpsData.clock.time_ns);
1678 }
1679 }
log() const1680 inline void LocEngReportGpsMeasurement::log() const {
1681 locallog();
1682 }
1683
1684 /*********************************************************************
1685 * Initialization checking macros
1686 *********************************************************************/
1687 #define STATE_CHECK(ctx, x, ret) \
1688 if (!(ctx)) \
1689 { \
1690 /* Not intialized, abort */\
1691 LOC_LOGE("%s: log_eng state error: %s", __func__, x); \
1692 EXIT_LOG(%s, x); \
1693 ret; \
1694 }
1695 #define INIT_CHECK(ctx, ret) STATE_CHECK(ctx, "instance not initialized", ret)
1696
1697 /*===========================================================================
1698 FUNCTION loc_eng_init
1699
1700 DESCRIPTION
1701 Initialize the location engine, this include setting up global datas
1702 and registers location engien with loc api service.
1703
1704 DEPENDENCIES
1705 None
1706
1707 RETURN VALUE
1708 0: success
1709
1710 SIDE EFFECTS
1711 N/A
1712
1713 ===========================================================================*/
loc_eng_init(loc_eng_data_s_type & loc_eng_data,LocCallbacks * callbacks,LOC_API_ADAPTER_EVENT_MASK_T event,ContextBase * context)1714 int loc_eng_init(loc_eng_data_s_type &loc_eng_data, LocCallbacks* callbacks,
1715 LOC_API_ADAPTER_EVENT_MASK_T event, ContextBase* context)
1716
1717 {
1718 int ret_val = 0;
1719
1720 ENTRY_LOG_CALLFLOW();
1721 if (NULL == callbacks || 0 == event) {
1722 LOC_LOGE("loc_eng_init: bad parameters cb %p eMask %d", callbacks, event);
1723 ret_val = -1;
1724 EXIT_LOG(%d, ret_val);
1725 return ret_val;
1726 }
1727
1728 STATE_CHECK((NULL == loc_eng_data.adapter),
1729 "instance already initialized", return 0);
1730
1731 memset(&loc_eng_data, 0, sizeof (loc_eng_data));
1732
1733 // Save callbacks
1734 loc_eng_data.location_cb = callbacks->location_cb;
1735 loc_eng_data.sv_status_cb = callbacks->sv_status_cb;
1736 loc_eng_data.status_cb = callbacks->status_cb;
1737 loc_eng_data.nmea_cb = callbacks->nmea_cb;
1738 loc_eng_data.set_capabilities_cb = callbacks->set_capabilities_cb;
1739 loc_eng_data.acquire_wakelock_cb = callbacks->acquire_wakelock_cb;
1740 loc_eng_data.release_wakelock_cb = callbacks->release_wakelock_cb;
1741 loc_eng_data.request_utc_time_cb = callbacks->request_utc_time_cb;
1742 loc_eng_data.location_ext_parser = callbacks->location_ext_parser ?
1743 callbacks->location_ext_parser : noProc;
1744 loc_eng_data.sv_ext_parser = callbacks->sv_ext_parser ?
1745 callbacks->sv_ext_parser : noProc;
1746 loc_eng_data.intermediateFix = gps_conf.INTERMEDIATE_POS;
1747 loc_eng_data.shutdown_cb = callbacks->shutdown_cb;
1748 // initial states taken care of by the memset above
1749 // loc_eng_data.engine_status -- GPS_STATUS_NONE;
1750 // loc_eng_data.fix_session_status -- GPS_STATUS_NONE;
1751 // loc_eng_data.mute_session_state -- LOC_MUTE_SESS_NONE;
1752
1753 if ((event & LOC_API_ADAPTER_BIT_NMEA_1HZ_REPORT) && (gps_conf.NMEA_PROVIDER == NMEA_PROVIDER_AP))
1754 {
1755 event = event ^ LOC_API_ADAPTER_BIT_NMEA_1HZ_REPORT; // unregister for modem NMEA report
1756 loc_eng_data.generateNmea = true;
1757 }
1758 else
1759 {
1760 loc_eng_data.generateNmea = false;
1761 }
1762
1763 loc_eng_data.adapter =
1764 new LocEngAdapter(event, &loc_eng_data, context,
1765 (MsgTask::tCreate)callbacks->create_thread_cb);
1766
1767 LOC_LOGD("loc_eng_init created client, id = %p\n",
1768 loc_eng_data.adapter);
1769 loc_eng_data.adapter->sendMsg(new LocEngInit(&loc_eng_data));
1770
1771 EXIT_LOG(%d, ret_val);
1772 return ret_val;
1773 }
1774
loc_eng_reinit(loc_eng_data_s_type & loc_eng_data)1775 static int loc_eng_reinit(loc_eng_data_s_type &loc_eng_data)
1776 {
1777 ENTRY_LOG();
1778 int ret_val = LOC_API_ADAPTER_ERR_SUCCESS;
1779
1780 if (LOC_API_ADAPTER_ERR_SUCCESS == ret_val) {
1781 LOC_LOGD("loc_eng_reinit reinit() successful");
1782
1783 LocEngAdapter* adapter = loc_eng_data.adapter;
1784 adapter->sendMsg(new LocEngGnssConstellationConfig(adapter));
1785 adapter->sendMsg(new LocEngSuplVer(adapter, gps_conf.SUPL_VER));
1786 adapter->sendMsg(new LocEngLppConfig(adapter, gps_conf.LPP_PROFILE));
1787 adapter->sendMsg(new LocEngSensorControlConfig(adapter, sap_conf.SENSOR_USAGE,
1788 sap_conf.SENSOR_PROVIDER));
1789 adapter->sendMsg(new LocEngAGlonassProtocol(adapter, gps_conf.A_GLONASS_POS_PROTOCOL_SELECT));
1790
1791 /* Make sure at least one of the sensor property is specified by the user in the gps.conf file. */
1792 if( sap_conf.GYRO_BIAS_RANDOM_WALK_VALID ||
1793 sap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY_VALID ||
1794 sap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY_VALID ||
1795 sap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY_VALID ||
1796 sap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY_VALID )
1797 {
1798 adapter->sendMsg(new LocEngSensorProperties(adapter,
1799 sap_conf.GYRO_BIAS_RANDOM_WALK_VALID,
1800 sap_conf.GYRO_BIAS_RANDOM_WALK,
1801 sap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY_VALID,
1802 sap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY,
1803 sap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY_VALID,
1804 sap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY,
1805 sap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY_VALID,
1806 sap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY,
1807 sap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY_VALID,
1808 sap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY));
1809 }
1810
1811 adapter->sendMsg(new LocEngSensorPerfControlConfig(adapter,
1812 sap_conf.SENSOR_CONTROL_MODE,
1813 sap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH,
1814 sap_conf.SENSOR_ACCEL_BATCHES_PER_SEC,
1815 sap_conf.SENSOR_GYRO_SAMPLES_PER_BATCH,
1816 sap_conf.SENSOR_GYRO_BATCHES_PER_SEC,
1817 sap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH_HIGH,
1818 sap_conf.SENSOR_ACCEL_BATCHES_PER_SEC_HIGH,
1819 sap_conf.SENSOR_GYRO_SAMPLES_PER_BATCH_HIGH,
1820 sap_conf.SENSOR_GYRO_BATCHES_PER_SEC_HIGH,
1821 sap_conf.SENSOR_ALGORITHM_CONFIG_MASK));
1822
1823 adapter->sendMsg(new LocEngEnableData(adapter, NULL, 0, (agpsStatus ? 1:0)));
1824 }
1825
1826 EXIT_LOG(%d, ret_val);
1827 return ret_val;
1828 }
1829
1830 /*===========================================================================
1831 FUNCTION loc_eng_cleanup
1832
1833 DESCRIPTION
1834 Cleans location engine. The location client handle will be released.
1835
1836 DEPENDENCIES
1837 None
1838
1839 RETURN VALUE
1840 None
1841
1842 SIDE EFFECTS
1843 N/A
1844
1845 ===========================================================================*/
loc_eng_cleanup(loc_eng_data_s_type & loc_eng_data)1846 void loc_eng_cleanup(loc_eng_data_s_type &loc_eng_data)
1847 {
1848 ENTRY_LOG_CALLFLOW();
1849 INIT_CHECK(loc_eng_data.adapter, return);
1850
1851 // XTRA has no state, so we are fine with it.
1852
1853 // we need to check and clear NI
1854 #if 0
1855 // we need to check and clear ATL
1856 if (NULL != loc_eng_data.agnss_nif) {
1857 delete loc_eng_data.agnss_nif;
1858 loc_eng_data.agnss_nif = NULL;
1859 }
1860 if (NULL != loc_eng_data.internet_nif) {
1861 delete loc_eng_data.internet_nif;
1862 loc_eng_data.internet_nif = NULL;
1863 }
1864 #endif
1865 if (loc_eng_data.adapter->isInSession())
1866 {
1867 LOC_LOGD("loc_eng_cleanup: fix not stopped. stop it now.");
1868 loc_eng_stop(loc_eng_data);
1869 }
1870
1871 #if 0 // can't afford to actually clean up, for many reason.
1872
1873 LOC_LOGD("loc_eng_init: client opened. close it now.");
1874 delete loc_eng_data.adapter;
1875 loc_eng_data.adapter = NULL;
1876
1877 loc_eng_dmn_conn_loc_api_server_unblock();
1878 loc_eng_dmn_conn_loc_api_server_join();
1879
1880 #endif
1881
1882 EXIT_LOG(%s, VOID_RET);
1883 }
1884
1885
1886 /*===========================================================================
1887 FUNCTION loc_eng_start
1888
1889 DESCRIPTION
1890 Starts the tracking session
1891
1892 DEPENDENCIES
1893 None
1894
1895 RETURN VALUE
1896 0: success
1897
1898 SIDE EFFECTS
1899 N/A
1900
1901 ===========================================================================*/
loc_eng_start(loc_eng_data_s_type & loc_eng_data)1902 int loc_eng_start(loc_eng_data_s_type &loc_eng_data)
1903 {
1904 ENTRY_LOG_CALLFLOW();
1905 INIT_CHECK(loc_eng_data.adapter, return -1);
1906
1907 if(! loc_eng_data.adapter->getUlpProxy()->sendStartFix())
1908 {
1909 loc_eng_data.adapter->sendMsg(new LocEngStartFix(loc_eng_data.adapter));
1910 }
1911
1912 EXIT_LOG(%d, 0);
1913 return 0;
1914 }
1915
loc_eng_start_handler(loc_eng_data_s_type & loc_eng_data)1916 static int loc_eng_start_handler(loc_eng_data_s_type &loc_eng_data)
1917 {
1918 ENTRY_LOG();
1919 int ret_val = LOC_API_ADAPTER_ERR_SUCCESS;
1920
1921 if (!loc_eng_data.adapter->isInSession()) {
1922 ret_val = loc_eng_data.adapter->startFix();
1923
1924 if (ret_val == LOC_API_ADAPTER_ERR_SUCCESS ||
1925 ret_val == LOC_API_ADAPTER_ERR_ENGINE_DOWN)
1926 {
1927 loc_eng_data.adapter->setInSession(TRUE);
1928 loc_inform_gps_status(loc_eng_data, GPS_STATUS_SESSION_BEGIN);
1929 }
1930 }
1931
1932 EXIT_LOG(%d, ret_val);
1933 return ret_val;
1934 }
1935
1936 /*===========================================================================
1937 FUNCTION loc_eng_stop_wrapper
1938
1939 DESCRIPTION
1940 Stops the tracking session
1941
1942 DEPENDENCIES
1943 None
1944
1945 RETURN VALUE
1946 0: success
1947
1948 SIDE EFFECTS
1949 N/A
1950
1951 ===========================================================================*/
loc_eng_stop(loc_eng_data_s_type & loc_eng_data)1952 int loc_eng_stop(loc_eng_data_s_type &loc_eng_data)
1953 {
1954 ENTRY_LOG_CALLFLOW();
1955 INIT_CHECK(loc_eng_data.adapter, return -1);
1956
1957 if(! loc_eng_data.adapter->getUlpProxy()->sendStopFix())
1958 {
1959 loc_eng_data.adapter->sendMsg(new LocEngStopFix(loc_eng_data.adapter));
1960 }
1961
1962 EXIT_LOG(%d, 0);
1963 return 0;
1964 }
1965
loc_eng_stop_handler(loc_eng_data_s_type & loc_eng_data)1966 static int loc_eng_stop_handler(loc_eng_data_s_type &loc_eng_data)
1967 {
1968 ENTRY_LOG();
1969 int ret_val = LOC_API_ADAPTER_ERR_SUCCESS;
1970
1971 if (loc_eng_data.adapter->isInSession()) {
1972
1973 ret_val = loc_eng_data.adapter->stopFix();
1974 if (ret_val == LOC_API_ADAPTER_ERR_SUCCESS)
1975 {
1976 loc_inform_gps_status(loc_eng_data, GPS_STATUS_SESSION_END);
1977 }
1978
1979 loc_eng_data.adapter->setInSession(FALSE);
1980 }
1981
1982 EXIT_LOG(%d, ret_val);
1983 return ret_val;
1984 }
1985
1986 /*===========================================================================
1987 FUNCTION loc_eng_mute_one_session
1988
1989 DESCRIPTION
1990 Mutes one session
1991
1992 DEPENDENCIES
1993 None
1994
1995 RETURN VALUE
1996 0: Success
1997
1998 SIDE EFFECTS
1999 N/A
2000
2001 ===========================================================================*/
loc_eng_mute_one_session(loc_eng_data_s_type & loc_eng_data)2002 void loc_eng_mute_one_session(loc_eng_data_s_type &loc_eng_data)
2003 {
2004 ENTRY_LOG();
2005 loc_eng_data.mute_session_state = LOC_MUTE_SESS_WAIT;
2006 EXIT_LOG(%s, VOID_RET);
2007 }
2008
2009 /*===========================================================================
2010 FUNCTION loc_eng_set_position_mode
2011
2012 DESCRIPTION
2013 Sets the mode and fix frequency for the tracking session.
2014
2015 DEPENDENCIES
2016 None
2017
2018 RETURN VALUE
2019 0: success
2020
2021 SIDE EFFECTS
2022 N/A
2023
2024 ===========================================================================*/
loc_eng_set_position_mode(loc_eng_data_s_type & loc_eng_data,LocPosMode & params)2025 int loc_eng_set_position_mode(loc_eng_data_s_type &loc_eng_data,
2026 LocPosMode ¶ms)
2027 {
2028 ENTRY_LOG_CALLFLOW();
2029 INIT_CHECK(loc_eng_data.adapter, return -1);
2030
2031 int gnssType = getTargetGnssType(loc_get_target());
2032
2033 // The position mode for GSS/QCA1530 can only be standalone
2034 bool is1530 = gnssType == GNSS_QCA1530;
2035 bool isAPQ = gnssType == GNSS_GSS;
2036 if ((isAPQ || is1530) && params.mode != LOC_POSITION_MODE_STANDALONE) {
2037 params.mode = LOC_POSITION_MODE_STANDALONE;
2038 LOC_LOGD("Position mode changed to standalone for target with GSS/qca1530.");
2039 }
2040
2041 if(! loc_eng_data.adapter->getUlpProxy()->sendFixMode(params))
2042 {
2043 LocEngAdapter* adapter = loc_eng_data.adapter;
2044 adapter->sendMsg(new LocEngPositionMode(adapter, params));
2045 }
2046
2047 EXIT_LOG(%d, 0);
2048 return 0;
2049 }
2050
2051 /*===========================================================================
2052 FUNCTION loc_eng_inject_time
2053
2054 DESCRIPTION
2055 This is used by Java native function to do time injection.
2056
2057 DEPENDENCIES
2058 None
2059
2060 RETURN VALUE
2061 0
2062
2063 SIDE EFFECTS
2064 N/A
2065
2066 ===========================================================================*/
loc_eng_inject_time(loc_eng_data_s_type & loc_eng_data,GpsUtcTime time,int64_t timeReference,int uncertainty)2067 int loc_eng_inject_time(loc_eng_data_s_type &loc_eng_data, GpsUtcTime time,
2068 int64_t timeReference, int uncertainty)
2069 {
2070 ENTRY_LOG_CALLFLOW();
2071 INIT_CHECK(loc_eng_data.adapter, return -1);
2072 LocEngAdapter* adapter = loc_eng_data.adapter;
2073
2074 adapter->sendMsg(new LocEngSetTime(adapter, time, timeReference,
2075 uncertainty));
2076
2077 EXIT_LOG(%d, 0);
2078 return 0;
2079 }
2080
2081
2082 /*===========================================================================
2083 FUNCTION loc_eng_inject_location
2084
2085 DESCRIPTION
2086 This is used by Java native function to do location injection.
2087
2088 DEPENDENCIES
2089 None
2090
2091 RETURN VALUE
2092 0 : Successful
2093 error code : Failure
2094
2095 SIDE EFFECTS
2096 N/A
2097 ===========================================================================*/
loc_eng_inject_location(loc_eng_data_s_type & loc_eng_data,double latitude,double longitude,float accuracy)2098 int loc_eng_inject_location(loc_eng_data_s_type &loc_eng_data, double latitude,
2099 double longitude, float accuracy)
2100 {
2101 ENTRY_LOG_CALLFLOW();
2102 INIT_CHECK(loc_eng_data.adapter, return -1);
2103 LocEngAdapter* adapter = loc_eng_data.adapter;
2104 if(adapter->mSupportsPositionInjection)
2105 {
2106 adapter->sendMsg(new LocEngInjectLocation(adapter, latitude, longitude,
2107 accuracy));
2108 }
2109
2110 EXIT_LOG(%d, 0);
2111 return 0;
2112 }
2113
2114
2115 /*===========================================================================
2116 FUNCTION loc_eng_delete_aiding_data
2117
2118 DESCRIPTION
2119 This is used by Java native function to delete the aiding data. The function
2120 updates the global variable for the aiding data to be deleted. If the GPS
2121 engine is off, the aiding data will be deleted. Otherwise, the actual action
2122 will happen when gps engine is turned off.
2123
2124 DEPENDENCIES
2125 Assumes the aiding data type specified in GpsAidingData matches with
2126 LOC API specification.
2127
2128 RETURN VALUE
2129 None
2130
2131 SIDE EFFECTS
2132 N/A
2133
2134 ===========================================================================*/
loc_eng_delete_aiding_data(loc_eng_data_s_type & loc_eng_data,GpsAidingData f)2135 void loc_eng_delete_aiding_data(loc_eng_data_s_type &loc_eng_data, GpsAidingData f)
2136 {
2137 ENTRY_LOG_CALLFLOW();
2138 INIT_CHECK(loc_eng_data.adapter, return);
2139
2140 loc_eng_data.adapter->sendMsg(new LocEngDelAidData(&loc_eng_data, f));
2141
2142 EXIT_LOG(%s, VOID_RET);
2143 }
2144
2145 /*===========================================================================
2146
2147 FUNCTION loc_inform_gps_state
2148
2149 DESCRIPTION
2150 Informs the GPS Provider about the GPS status
2151
2152 DEPENDENCIES
2153 None
2154
2155 RETURN VALUE
2156 None
2157
2158 SIDE EFFECTS
2159 N/A
2160
2161 ===========================================================================*/
loc_inform_gps_status(loc_eng_data_s_type & loc_eng_data,GpsStatusValue status)2162 static void loc_inform_gps_status(loc_eng_data_s_type &loc_eng_data, GpsStatusValue status)
2163 {
2164 ENTRY_LOG();
2165
2166 if (loc_eng_data.status_cb)
2167 {
2168 GpsStatus gs = { sizeof(gs),status };
2169 CALLBACK_LOG_CALLFLOW("status_cb", %s,
2170 loc_get_gps_status_name(gs.status));
2171 loc_eng_data.status_cb(&gs);
2172 }
2173
2174 EXIT_LOG(%s, VOID_RET);
2175 }
2176
loc_eng_get_zpp_handler(loc_eng_data_s_type & loc_eng_data)2177 static int loc_eng_get_zpp_handler(loc_eng_data_s_type &loc_eng_data)
2178 {
2179 ENTRY_LOG();
2180 int ret_val = LOC_API_ADAPTER_ERR_SUCCESS;
2181 UlpLocation location;
2182 LocPosTechMask tech_mask = LOC_POS_TECH_MASK_DEFAULT;
2183 GpsLocationExtended locationExtended;
2184 memset(&locationExtended, 0, sizeof (GpsLocationExtended));
2185 locationExtended.size = sizeof(locationExtended);
2186 memset(&location, 0, sizeof location);
2187
2188 ret_val = loc_eng_data.adapter->getZpp(location.gpsLocation, tech_mask);
2189 //Mark the location source as from ZPP
2190 location.gpsLocation.flags |= LOCATION_HAS_SOURCE_INFO;
2191 location.position_source = ULP_LOCATION_IS_FROM_ZPP;
2192
2193 loc_eng_data.adapter->getUlpProxy()->reportPosition(location,
2194 locationExtended,
2195 NULL,
2196 LOC_SESS_SUCCESS,
2197 tech_mask);
2198
2199 EXIT_LOG(%d, ret_val);
2200 return ret_val;
2201 }
2202
2203 /*
2204 Callback function passed to Data Services State Machine
2205 This becomes part of the state machine's servicer and
2206 is used to send requests to the data services client
2207 */
dataCallCb(void * cb_data)2208 static int dataCallCb(void *cb_data)
2209 {
2210 LOC_LOGD("Enter dataCallCb\n");
2211 int ret=0;
2212 if(cb_data != NULL) {
2213 dsCbData *cbData = (dsCbData *)cb_data;
2214 LocEngAdapter *locAdapter = (LocEngAdapter *)cbData->mAdapter;
2215 if(cbData->action == GPS_REQUEST_AGPS_DATA_CONN) {
2216 LOC_LOGD("dataCallCb GPS_REQUEST_AGPS_DATA_CONN\n");
2217 ret = locAdapter->openAndStartDataCall();
2218 }
2219 else if(cbData->action == GPS_RELEASE_AGPS_DATA_CONN) {
2220 LOC_LOGD("dataCallCb GPS_RELEASE_AGPS_DATA_CONN\n");
2221 locAdapter->stopDataCall();
2222 }
2223 }
2224 else {
2225 LOC_LOGE("NULL argument received. Failing.\n");
2226 ret = -1;
2227 goto err;
2228 }
2229
2230 err:
2231 LOC_LOGD("Exit dataCallCb ret = %d\n", ret);
2232 return ret;
2233 }
2234
2235 /*===========================================================================
2236 FUNCTION loc_eng_agps_reinit
2237
2238 DESCRIPTION
2239 2nd half of loc_eng_agps_init(), singled out for modem restart to use.
2240
2241 DEPENDENCIES
2242 NONE
2243
2244 RETURN VALUE
2245 0
2246
2247 SIDE EFFECTS
2248 N/A
2249
2250 ===========================================================================*/
loc_eng_agps_reinit(loc_eng_data_s_type & loc_eng_data)2251 static void loc_eng_agps_reinit(loc_eng_data_s_type &loc_eng_data)
2252 {
2253 ENTRY_LOG();
2254
2255 // Set server addresses which came before init
2256 if (loc_eng_data.supl_host_set)
2257 {
2258 loc_eng_set_server(loc_eng_data, LOC_AGPS_SUPL_SERVER,
2259 loc_eng_data.supl_host_buf,
2260 loc_eng_data.supl_port_buf);
2261 }
2262
2263 if (loc_eng_data.c2k_host_set)
2264 {
2265 loc_eng_set_server(loc_eng_data, LOC_AGPS_CDMA_PDE_SERVER,
2266 loc_eng_data.c2k_host_buf,
2267 loc_eng_data.c2k_port_buf);
2268 }
2269 EXIT_LOG(%s, VOID_RET);
2270 }
2271 /*===========================================================================
2272 FUNCTION loc_eng_agps_init
2273
2274 DESCRIPTION
2275 Initialize the AGps interface.
2276
2277 DEPENDENCIES
2278 NONE
2279
2280 RETURN VALUE
2281 0
2282
2283 SIDE EFFECTS
2284 N/A
2285
2286 ===========================================================================*/
loc_eng_agps_init(loc_eng_data_s_type & loc_eng_data,AGpsExtCallbacks * callbacks)2287 void loc_eng_agps_init(loc_eng_data_s_type &loc_eng_data, AGpsExtCallbacks* callbacks)
2288 {
2289 ENTRY_LOG_CALLFLOW();
2290 INIT_CHECK(loc_eng_data.adapter, return);
2291 STATE_CHECK((NULL == loc_eng_data.agps_status_cb),
2292 "agps instance already initialized",
2293 return);
2294 if (callbacks == NULL) {
2295 LOC_LOGE("loc_eng_agps_init: bad parameters cb %p", callbacks);
2296 EXIT_LOG(%s, VOID_RET);
2297 return;
2298 }
2299 LocEngAdapter* adapter = loc_eng_data.adapter;
2300 loc_eng_data.agps_status_cb = callbacks->status_cb;
2301
2302 loc_eng_data.internet_nif = new AgpsStateMachine(servicerTypeAgps,
2303 (void *)loc_eng_data.agps_status_cb,
2304 AGPS_TYPE_WWAN_ANY,
2305 false);
2306 loc_eng_data.wifi_nif = new AgpsStateMachine(servicerTypeAgps,
2307 (void *)loc_eng_data.agps_status_cb,
2308 AGPS_TYPE_WIFI,
2309 true);
2310
2311 int gnssType = getTargetGnssType(loc_get_target());
2312 bool isAPQ = (gnssType == GNSS_GSS);
2313 bool is1530 = (gnssType == GNSS_QCA1530);
2314 if (!isAPQ && !is1530) {
2315 loc_eng_data.agnss_nif = new AgpsStateMachine(servicerTypeAgps,
2316 (void *)loc_eng_data.agps_status_cb,
2317 AGPS_TYPE_SUPL,
2318 false);
2319
2320 if (adapter->mSupportsAgpsRequests) {
2321 loc_eng_data.adapter->sendMsg(new LocEngDataClientInit(&loc_eng_data));
2322
2323 loc_eng_dmn_conn_loc_api_server_launch(callbacks->create_thread_cb,
2324 NULL, NULL, &loc_eng_data);
2325 }
2326 loc_eng_agps_reinit(loc_eng_data);
2327 }
2328
2329 EXIT_LOG(%s, VOID_RET);
2330 }
2331
deleteAidingData(loc_eng_data_s_type & logEng)2332 static void deleteAidingData(loc_eng_data_s_type &logEng) {
2333 if (logEng.engine_status != GPS_STATUS_ENGINE_ON &&
2334 logEng.aiding_data_for_deletion != 0) {
2335 logEng.adapter->deleteAidingData(logEng.aiding_data_for_deletion);
2336 logEng.aiding_data_for_deletion = 0;
2337 }
2338 }
2339
2340 static AgpsStateMachine*
getAgpsStateMachine(loc_eng_data_s_type & locEng,AGpsExtType agpsType)2341 getAgpsStateMachine(loc_eng_data_s_type &locEng, AGpsExtType agpsType) {
2342 AgpsStateMachine* stateMachine;
2343 switch (agpsType) {
2344 case AGPS_TYPE_WIFI: {
2345 stateMachine = locEng.wifi_nif;
2346 break;
2347 }
2348 case AGPS_TYPE_INVALID:
2349 case AGPS_TYPE_SUPL: {
2350 stateMachine = locEng.agnss_nif;
2351 break;
2352 }
2353 case AGPS_TYPE_SUPL_ES: {
2354 stateMachine = locEng.ds_nif;
2355 break;
2356 }
2357 default:
2358 stateMachine = locEng.internet_nif;
2359 }
2360 return stateMachine;
2361 }
2362
2363 /*===========================================================================
2364 FUNCTION loc_eng_agps_open
2365
2366 DESCRIPTION
2367 This function is called when on-demand data connection opening is successful.
2368 It should inform engine about the data open result.
2369
2370 DEPENDENCIES
2371 NONE
2372
2373 RETURN VALUE
2374 0
2375
2376 SIDE EFFECTS
2377 N/A
2378
2379 ===========================================================================*/
loc_eng_agps_open(loc_eng_data_s_type & loc_eng_data,AGpsExtType agpsType,const char * apn,AGpsBearerType bearerType)2380 int loc_eng_agps_open(loc_eng_data_s_type &loc_eng_data, AGpsExtType agpsType,
2381 const char* apn, AGpsBearerType bearerType)
2382 {
2383 ENTRY_LOG_CALLFLOW();
2384 INIT_CHECK(loc_eng_data.adapter && loc_eng_data.agps_status_cb,
2385 return -1);
2386
2387 if (apn == NULL)
2388 {
2389 LOC_LOGE("APN Name NULL\n");
2390 return 0;
2391 }
2392
2393 LOC_LOGD("loc_eng_agps_open APN name = [%s]", apn);
2394
2395 int apn_len = smaller_of(strlen (apn), MAX_APN_LEN);
2396 AgpsStateMachine* sm = getAgpsStateMachine(loc_eng_data, agpsType);
2397
2398 loc_eng_data.adapter->sendMsg(
2399 new LocEngAtlOpenSuccess(sm, apn, apn_len, bearerType));
2400
2401 EXIT_LOG(%d, 0);
2402 return 0;
2403 }
2404
2405 /*===========================================================================
2406 FUNCTION loc_eng_agps_closed
2407
2408 DESCRIPTION
2409 This function is called when on-demand data connection closing is done.
2410 It should inform engine about the data close result.
2411
2412 DEPENDENCIES
2413 NONE
2414
2415 RETURN VALUE
2416 0
2417
2418 SIDE EFFECTS
2419 N/A
2420
2421 ===========================================================================*/
loc_eng_agps_closed(loc_eng_data_s_type & loc_eng_data,AGpsExtType agpsType)2422 int loc_eng_agps_closed(loc_eng_data_s_type &loc_eng_data, AGpsExtType agpsType)
2423 {
2424 ENTRY_LOG_CALLFLOW();
2425 INIT_CHECK(loc_eng_data.adapter && loc_eng_data.agps_status_cb,
2426 return -1);
2427
2428 AgpsStateMachine* sm = getAgpsStateMachine(loc_eng_data, agpsType);
2429 loc_eng_data.adapter->sendMsg(new LocEngAtlClosed(sm));
2430
2431 EXIT_LOG(%d, 0);
2432 return 0;
2433 }
2434
2435 /*===========================================================================
2436 FUNCTION loc_eng_agps_open_failed
2437
2438 DESCRIPTION
2439 This function is called when on-demand data connection opening has failed.
2440 It should inform engine about the data open result.
2441
2442 DEPENDENCIES
2443 NONE
2444
2445 RETURN VALUE
2446 0
2447
2448 SIDE EFFECTS
2449 N/A
2450
2451 ===========================================================================*/
loc_eng_agps_open_failed(loc_eng_data_s_type & loc_eng_data,AGpsExtType agpsType)2452 int loc_eng_agps_open_failed(loc_eng_data_s_type &loc_eng_data, AGpsExtType agpsType)
2453 {
2454 ENTRY_LOG_CALLFLOW();
2455 INIT_CHECK(loc_eng_data.adapter && loc_eng_data.agps_status_cb,
2456 return -1);
2457
2458 AgpsStateMachine* sm = getAgpsStateMachine(loc_eng_data, agpsType);
2459 loc_eng_data.adapter->sendMsg(new LocEngAtlOpenFailed(sm));
2460
2461 EXIT_LOG(%d, 0);
2462 return 0;
2463 }
2464
2465 /*===========================================================================
2466
2467 FUNCTION resolve_in_addr
2468
2469 DESCRIPTION
2470 Translates a hostname to in_addr struct
2471
2472 DEPENDENCIES
2473 n/a
2474
2475 RETURN VALUE
2476 TRUE if successful
2477
2478 SIDE EFFECTS
2479 n/a
2480
2481 ===========================================================================*/
resolve_in_addr(const char * host_addr,struct in_addr * in_addr_ptr)2482 static boolean resolve_in_addr(const char *host_addr, struct in_addr *in_addr_ptr)
2483 {
2484 ENTRY_LOG();
2485 boolean ret_val = TRUE;
2486
2487 struct hostent *hp;
2488 hp = gethostbyname(host_addr);
2489 if (hp != NULL) /* DNS OK */
2490 {
2491 memcpy(in_addr_ptr, hp->h_addr_list[0], hp->h_length);
2492 }
2493 else
2494 {
2495 /* Try IP representation */
2496 if (inet_aton(host_addr, in_addr_ptr) == 0)
2497 {
2498 /* IP not valid */
2499 LOC_LOGE("DNS query on '%s' failed\n", host_addr);
2500 ret_val = FALSE;
2501 }
2502 }
2503
2504 EXIT_LOG(%s, loc_logger_boolStr[ret_val!=0]);
2505 return ret_val;
2506 }
2507
2508 /*===========================================================================
2509 FUNCTION loc_eng_set_server
2510
2511 DESCRIPTION
2512 This is used to set the default AGPS server. Server address is obtained
2513 from gps.conf.
2514
2515 DEPENDENCIES
2516 NONE
2517
2518 RETURN VALUE
2519 0
2520
2521 SIDE EFFECTS
2522 N/A
2523
2524 ===========================================================================*/
loc_eng_set_server(loc_eng_data_s_type & loc_eng_data,LocServerType type,const char * hostname,int port)2525 static int loc_eng_set_server(loc_eng_data_s_type &loc_eng_data,
2526 LocServerType type, const char* hostname, int port)
2527 {
2528 ENTRY_LOG();
2529 int ret = 0;
2530 LocEngAdapter* adapter = loc_eng_data.adapter;
2531
2532 if (LOC_AGPS_SUPL_SERVER == type) {
2533 char url[MAX_URL_LEN];
2534 unsigned int len = 0;
2535 const char nohost[] = "NONE";
2536 if (hostname == NULL ||
2537 strncasecmp(nohost, hostname, sizeof(nohost)) == 0) {
2538 url[0] = NULL;
2539 } else {
2540 len = snprintf(url, sizeof(url), "%s:%u", hostname, (unsigned) port);
2541 }
2542
2543 if (sizeof(url) > len) {
2544 adapter->sendMsg(new LocEngSetServerUrl(adapter, url, len));
2545 }
2546 } else if (LOC_AGPS_CDMA_PDE_SERVER == type ||
2547 LOC_AGPS_CUSTOM_PDE_SERVER == type ||
2548 LOC_AGPS_MPC_SERVER == type) {
2549 struct in_addr addr;
2550 if (!resolve_in_addr(hostname, &addr))
2551 {
2552 LOC_LOGE("loc_eng_set_server, hostname %s cannot be resolved.\n", hostname);
2553 ret = -2;
2554 } else {
2555 unsigned int ip = htonl(addr.s_addr);
2556 adapter->sendMsg(new LocEngSetServerIpv4(adapter, ip, port, type));
2557 }
2558 } else {
2559 LOC_LOGE("loc_eng_set_server, type %d cannot be resolved.\n", type);
2560 }
2561
2562 EXIT_LOG(%d, ret);
2563 return ret;
2564 }
2565
2566 /*===========================================================================
2567 FUNCTION loc_eng_set_server_proxy
2568
2569 DESCRIPTION
2570 If loc_eng_set_server is called before loc_eng_init, it doesn't work. This
2571 proxy buffers server settings and calls loc_eng_set_server when the client is
2572 open.
2573
2574 DEPENDENCIES
2575 NONE
2576
2577 RETURN VALUE
2578 0
2579
2580 SIDE EFFECTS
2581 N/A
2582
2583 ===========================================================================*/
loc_eng_set_server_proxy(loc_eng_data_s_type & loc_eng_data,LocServerType type,const char * hostname,int port)2584 int loc_eng_set_server_proxy(loc_eng_data_s_type &loc_eng_data,
2585 LocServerType type,
2586 const char* hostname, int port)
2587 {
2588 ENTRY_LOG_CALLFLOW();
2589 int ret_val = 0;
2590
2591 LOC_LOGV("save the address, type: %d, hostname: %s, port: %d",
2592 (int) type, hostname, port);
2593 switch (type)
2594 {
2595 case LOC_AGPS_SUPL_SERVER:
2596 strlcpy(loc_eng_data.supl_host_buf, hostname,
2597 sizeof(loc_eng_data.supl_host_buf));
2598 loc_eng_data.supl_port_buf = port;
2599 loc_eng_data.supl_host_set = 1;
2600 break;
2601 case LOC_AGPS_CDMA_PDE_SERVER:
2602 strlcpy(loc_eng_data.c2k_host_buf, hostname,
2603 sizeof(loc_eng_data.c2k_host_buf));
2604 loc_eng_data.c2k_port_buf = port;
2605 loc_eng_data.c2k_host_set = 1;
2606 break;
2607 default:
2608 LOC_LOGE("loc_eng_set_server_proxy, unknown server type = %d", (int) type);
2609 }
2610
2611 if (NULL != loc_eng_data.adapter)
2612 {
2613 ret_val = loc_eng_set_server(loc_eng_data, type, hostname, port);
2614 }
2615
2616 EXIT_LOG(%d, ret_val);
2617 return ret_val;
2618 }
2619
2620 /*===========================================================================
2621 FUNCTION loc_eng_agps_ril_update_network_availability
2622
2623 DESCRIPTION
2624 Sets data call allow vs disallow flag to modem
2625 This is the only member of sLocEngAGpsRilInterface implemented.
2626
2627 DEPENDENCIES
2628 None
2629
2630 RETURN VALUE
2631 0: success
2632
2633 SIDE EFFECTS
2634 N/A
2635
2636 ===========================================================================*/
loc_eng_agps_ril_update_network_availability(loc_eng_data_s_type & loc_eng_data,int available,const char * apn)2637 void loc_eng_agps_ril_update_network_availability(loc_eng_data_s_type &loc_eng_data,
2638 int available, const char* apn)
2639 {
2640 ENTRY_LOG_CALLFLOW();
2641
2642 //This is to store the status of data availability over the network.
2643 //If GPS is not enabled, the INIT_CHECK will fail and the modem will
2644 //not be updated with the network's availability. Since the data status
2645 //can change before GPS is enabled the, storing the status will enable
2646 //us to inform the modem after GPS is enabled
2647 agpsStatus = available;
2648
2649 INIT_CHECK(loc_eng_data.adapter, return);
2650 if (apn != NULL)
2651 {
2652 LOC_LOGD("loc_eng_agps_ril_update_network_availability: APN Name = [%s]\n", apn);
2653 int apn_len = smaller_of(strlen (apn), MAX_APN_LEN);
2654 LocEngAdapter* adapter = loc_eng_data.adapter;
2655 adapter->sendMsg(new LocEngEnableData(adapter, apn, apn_len, available));
2656 }
2657 EXIT_LOG(%s, VOID_RET);
2658 }
2659
loc_eng_agps_install_certificates(loc_eng_data_s_type & loc_eng_data,const DerEncodedCertificate * certificates,size_t numberOfCerts)2660 int loc_eng_agps_install_certificates(loc_eng_data_s_type &loc_eng_data,
2661 const DerEncodedCertificate* certificates,
2662 size_t numberOfCerts)
2663 {
2664 ENTRY_LOG_CALLFLOW();
2665 int ret_val = AGPS_CERTIFICATE_OPERATION_SUCCESS;
2666
2667 uint32_t slotBitMask = gps_conf.AGPS_CERT_WRITABLE_MASK;
2668 uint32_t slotCount = 0;
2669 for (uint32_t slotBitMaskCounter=slotBitMask; slotBitMaskCounter; slotCount++) {
2670 slotBitMaskCounter &= slotBitMaskCounter - 1;
2671 }
2672 LOC_LOGD("SlotBitMask=%u SlotCount=%u NumberOfCerts=%u",
2673 slotBitMask, slotCount, numberOfCerts);
2674
2675 LocEngAdapter* adapter = loc_eng_data.adapter;
2676
2677 if (numberOfCerts == 0) {
2678 LOC_LOGE("No certs to install, since numberOfCerts is zero");
2679 ret_val = AGPS_CERTIFICATE_OPERATION_SUCCESS;
2680 } else if (!adapter) {
2681 LOC_LOGE("adapter is null!");
2682 ret_val = AGPS_CERTIFICATE_ERROR_GENERIC;
2683 } else if (slotCount < numberOfCerts) {
2684 LOC_LOGE("Not enough cert slots (%u) to install %u certs!",
2685 slotCount, numberOfCerts);
2686 ret_val = AGPS_CERTIFICATE_ERROR_TOO_MANY_CERTIFICATES;
2687 } else {
2688 for (int i=0; i < numberOfCerts; ++i)
2689 {
2690 if (certificates[i].length > AGPS_CERTIFICATE_MAX_LENGTH) {
2691 LOC_LOGE("cert#(%u) length of %u is too big! greater than %u",
2692 certificates[i].length, AGPS_CERTIFICATE_MAX_LENGTH);
2693 ret_val = AGPS_CERTIFICATE_ERROR_GENERIC;
2694 break;
2695 }
2696 }
2697
2698 if (ret_val == AGPS_CERTIFICATE_OPERATION_SUCCESS) {
2699 adapter->sendMsg(new LocEngInstallAGpsCert(adapter,
2700 certificates,
2701 numberOfCerts,
2702 slotBitMask));
2703 }
2704 }
2705
2706 EXIT_LOG(%d, ret_val);
2707 return ret_val;
2708 }
2709
loc_eng_configuration_update(loc_eng_data_s_type & loc_eng_data,const char * config_data,int32_t length)2710 void loc_eng_configuration_update (loc_eng_data_s_type &loc_eng_data,
2711 const char* config_data, int32_t length)
2712 {
2713 ENTRY_LOG_CALLFLOW();
2714
2715 if (config_data && length > 0) {
2716 loc_gps_cfg_s_type gps_conf_tmp = gps_conf;
2717 UTIL_UPDATE_CONF(config_data, length, gps_conf_table);
2718 LocEngAdapter* adapter = loc_eng_data.adapter;
2719
2720 // it is possible that HAL is not init'ed at this time
2721 if (adapter) {
2722 if (gps_conf_tmp.SUPL_VER != gps_conf.SUPL_VER) {
2723 adapter->sendMsg(new LocEngSuplVer(adapter, gps_conf.SUPL_VER));
2724 }
2725 if (gps_conf_tmp.LPP_PROFILE != gps_conf.LPP_PROFILE) {
2726 adapter->sendMsg(new LocEngLppConfig(adapter, gps_conf.LPP_PROFILE));
2727 }
2728 if (gps_conf_tmp.A_GLONASS_POS_PROTOCOL_SELECT != gps_conf.A_GLONASS_POS_PROTOCOL_SELECT) {
2729 adapter->sendMsg(new LocEngAGlonassProtocol(adapter,
2730 gps_conf.A_GLONASS_POS_PROTOCOL_SELECT));
2731 }
2732 }
2733
2734 gps_conf_tmp.SUPL_VER = gps_conf.SUPL_VER;
2735 gps_conf_tmp.LPP_PROFILE = gps_conf.LPP_PROFILE;
2736 gps_conf_tmp.A_GLONASS_POS_PROTOCOL_SELECT = gps_conf.A_GLONASS_POS_PROTOCOL_SELECT;
2737 gps_conf_tmp.GPS_LOCK = gps_conf.GPS_LOCK;
2738 gps_conf = gps_conf_tmp;
2739 }
2740
2741 EXIT_LOG(%s, VOID_RET);
2742 }
2743
2744 /*===========================================================================
2745 FUNCTION loc_eng_report_status
2746
2747 DESCRIPTION
2748 Reports GPS engine state to Java layer.
2749
2750 DEPENDENCIES
2751 N/A
2752
2753 RETURN VALUE
2754 N/A
2755
2756 SIDE EFFECTS
2757 N/A
2758
2759 ===========================================================================*/
loc_eng_report_status(loc_eng_data_s_type & loc_eng_data,GpsStatusValue status)2760 static void loc_eng_report_status (loc_eng_data_s_type &loc_eng_data, GpsStatusValue status)
2761 {
2762 ENTRY_LOG();
2763 // Switch from WAIT to MUTE, for "engine on" or "session begin" event
2764 if (status == GPS_STATUS_SESSION_BEGIN || status == GPS_STATUS_ENGINE_ON)
2765 {
2766 if (loc_eng_data.mute_session_state == LOC_MUTE_SESS_WAIT)
2767 {
2768 LOC_LOGD("loc_eng_report_status: mute_session_state changed from WAIT to IN SESSION");
2769 loc_eng_data.mute_session_state = LOC_MUTE_SESS_IN_SESSION;
2770 }
2771 }
2772
2773 // Switch off MUTE session
2774 if (loc_eng_data.mute_session_state == LOC_MUTE_SESS_IN_SESSION &&
2775 (status == GPS_STATUS_SESSION_END || status == GPS_STATUS_ENGINE_OFF))
2776 {
2777 LOC_LOGD("loc_eng_report_status: mute_session_state changed from IN SESSION to NONE");
2778 loc_eng_data.mute_session_state = LOC_MUTE_SESS_NONE;
2779 }
2780
2781 // Session End is not reported during Android navigating state
2782 boolean navigating = loc_eng_data.adapter->isInSession();
2783 if (status != GPS_STATUS_NONE &&
2784 !(status == GPS_STATUS_SESSION_END && navigating) &&
2785 !(status == GPS_STATUS_SESSION_BEGIN && !navigating))
2786 {
2787 if (loc_eng_data.mute_session_state != LOC_MUTE_SESS_IN_SESSION)
2788 {
2789 // Inform GpsLocationProvider about mNavigating status
2790 loc_inform_gps_status(loc_eng_data, status);
2791 }
2792 else {
2793 LOC_LOGD("loc_eng_report_status: muting the status report.");
2794 }
2795 }
2796
2797 // Only keeps ENGINE ON/OFF in engine_status
2798 if (status == GPS_STATUS_ENGINE_ON || status == GPS_STATUS_ENGINE_OFF)
2799 {
2800 loc_eng_data.engine_status = status;
2801 }
2802
2803 // Only keeps SESSION BEGIN/END in fix_session_status
2804 if (status == GPS_STATUS_SESSION_BEGIN || status == GPS_STATUS_SESSION_END)
2805 {
2806 loc_eng_data.fix_session_status = status;
2807 }
2808 EXIT_LOG(%s, VOID_RET);
2809 }
2810
2811 /*===========================================================================
2812 FUNCTION loc_eng_handle_engine_down
2813 loc_eng_handle_engine_up
2814
2815 DESCRIPTION
2816 Calls this function when it is detected that modem restart is happening.
2817 Either we detected the modem is down or received modem up event.
2818 This must be called from the deferred thread to avoid race condition.
2819
2820 DEPENDENCIES
2821 None
2822
2823 RETURN VALUE
2824 None
2825
2826 SIDE EFFECTS
2827 N/A
2828
2829 ===========================================================================*/
loc_eng_handle_engine_down(loc_eng_data_s_type & loc_eng_data)2830 void loc_eng_handle_engine_down(loc_eng_data_s_type &loc_eng_data)
2831 {
2832 ENTRY_LOG();
2833 loc_eng_ni_reset_on_engine_restart(loc_eng_data);
2834 loc_eng_report_status(loc_eng_data, GPS_STATUS_ENGINE_OFF);
2835 EXIT_LOG(%s, VOID_RET);
2836 }
2837
loc_eng_handle_engine_up(loc_eng_data_s_type & loc_eng_data)2838 void loc_eng_handle_engine_up(loc_eng_data_s_type &loc_eng_data)
2839 {
2840 ENTRY_LOG();
2841 loc_eng_reinit(loc_eng_data);
2842
2843 loc_eng_data.adapter->requestPowerVote();
2844
2845 if (loc_eng_data.agps_status_cb != NULL) {
2846 if (loc_eng_data.agnss_nif)
2847 loc_eng_data.agnss_nif->dropAllSubscribers();
2848 if (loc_eng_data.internet_nif)
2849 loc_eng_data.internet_nif->dropAllSubscribers();
2850
2851 loc_eng_agps_reinit(loc_eng_data);
2852 }
2853
2854 loc_eng_report_status(loc_eng_data, GPS_STATUS_ENGINE_ON);
2855
2856 // modem is back up. If we crashed in the middle of navigating, we restart.
2857 if (loc_eng_data.adapter->isInSession()) {
2858 // This sets the copy in adapter to modem
2859 loc_eng_data.adapter->setPositionMode(NULL);
2860 loc_eng_data.adapter->setInSession(false);
2861 loc_eng_start_handler(loc_eng_data);
2862 }
2863 EXIT_LOG(%s, VOID_RET);
2864 }
2865
2866 #ifdef USE_GLIB
2867 /*===========================================================================
2868 FUNCTION set_sched_policy
2869
2870 DESCRIPTION
2871 Local copy of this function which bypasses android set_sched_policy
2872
2873 DEPENDENCIES
2874 None
2875
2876 RETURN VALUE
2877 0
2878
2879 SIDE EFFECTS
2880 N/A
2881
2882 ===========================================================================*/
set_sched_policy(int tid,SchedPolicy policy)2883 static int set_sched_policy(int tid, SchedPolicy policy)
2884 {
2885 return 0;
2886 }
2887 #endif /* USE_GLIB */
2888
2889 /*===========================================================================
2890 FUNCTION loc_eng_read_config
2891
2892 DESCRIPTION
2893 Initiates the reading of the gps config file stored in /etc dir
2894
2895 DEPENDENCIES
2896 None
2897
2898 RETURN VALUE
2899 0: success
2900
2901 SIDE EFFECTS
2902 N/A
2903
2904 ===========================================================================*/
loc_eng_read_config(void)2905 int loc_eng_read_config(void)
2906 {
2907 ENTRY_LOG_CALLFLOW();
2908 if(configAlreadyRead == false)
2909 {
2910 // Initialize our defaults before reading of configuration file overwrites them.
2911 loc_default_parameters();
2912 // We only want to parse the conf file once. This is a good place to ensure that.
2913 // In fact one day the conf file should go into context.
2914 UTIL_READ_CONF(GPS_CONF_FILE, gps_conf_table);
2915 UTIL_READ_CONF(SAP_CONF_FILE, sap_conf_table);
2916 configAlreadyRead = true;
2917 } else {
2918 LOC_LOGV("GPS Config file has already been read\n");
2919 }
2920
2921 EXIT_LOG(%d, 0);
2922 return 0;
2923 }
2924
2925 /*===========================================================================
2926 FUNCTION loc_eng_handle_shutdown
2927
2928 DESCRIPTION
2929 Calls the shutdown callback function in the loc interface to close
2930 the modem node
2931
2932 DEPENDENCIES
2933 None
2934
2935 RETURN VALUE
2936 0: success
2937
2938 SIDE EFFECTS
2939 N/A
2940
2941 ===========================================================================*/
loc_eng_handle_shutdown(loc_eng_data_s_type & locEng)2942 void loc_eng_handle_shutdown(loc_eng_data_s_type &locEng)
2943 {
2944 ENTRY_LOG();
2945 locEng.shutdown_cb();
2946 EXIT_LOG(%d, 0);
2947 }
2948
2949 /*===========================================================================
2950 FUNCTION loc_eng_gps_measurement_init
2951
2952 DESCRIPTION
2953 Initialize gps measurement module.
2954
2955 DEPENDENCIES
2956 N/A
2957
2958 RETURN VALUE
2959 0: success
2960
2961 SIDE EFFECTS
2962 N/A
2963
2964 ===========================================================================*/
loc_eng_gps_measurement_init(loc_eng_data_s_type & loc_eng_data,GpsMeasurementCallbacks * callbacks)2965 int loc_eng_gps_measurement_init(loc_eng_data_s_type &loc_eng_data,
2966 GpsMeasurementCallbacks* callbacks)
2967 {
2968 ENTRY_LOG_CALLFLOW();
2969
2970 STATE_CHECK((NULL == loc_eng_data.gps_measurement_cb),
2971 "gps measurement already initialized",
2972 return GPS_MEASUREMENT_ERROR_ALREADY_INIT);
2973 STATE_CHECK((callbacks != NULL),
2974 "callbacks can not be NULL",
2975 return GPS_MEASUREMENT_ERROR_GENERIC);
2976 STATE_CHECK(loc_eng_data.adapter,
2977 "GpsInterface must be initialized first",
2978 return GPS_MEASUREMENT_ERROR_GENERIC);
2979
2980 // updated the mask
2981 LOC_API_ADAPTER_EVENT_MASK_T event = LOC_API_ADAPTER_BIT_GNSS_MEASUREMENT;
2982 loc_eng_data.adapter->sendMsg(new LocEngUpdateRegistrationMask(
2983 &loc_eng_data,
2984 event,
2985 LOC_REGISTRATION_MASK_ENABLED));
2986 // set up the callback
2987 loc_eng_data.gps_measurement_cb = callbacks->measurement_callback;
2988 LOC_LOGD ("%s, event masks updated successfully", __func__);
2989
2990 return GPS_MEASUREMENT_OPERATION_SUCCESS;
2991 }
2992
2993 /*===========================================================================
2994 FUNCTION loc_eng_gps_measurement_close
2995
2996 DESCRIPTION
2997 Close gps measurement module.
2998
2999 DEPENDENCIES
3000 N/A
3001
3002 RETURN VALUE
3003 N/A
3004
3005 SIDE EFFECTS
3006 N/A
3007
3008 ===========================================================================*/
loc_eng_gps_measurement_close(loc_eng_data_s_type & loc_eng_data)3009 void loc_eng_gps_measurement_close(loc_eng_data_s_type &loc_eng_data)
3010 {
3011 ENTRY_LOG_CALLFLOW();
3012
3013 INIT_CHECK(loc_eng_data.adapter, return);
3014
3015 // updated the mask
3016 LOC_API_ADAPTER_EVENT_MASK_T event = LOC_API_ADAPTER_BIT_GNSS_MEASUREMENT;
3017 loc_eng_data.adapter->sendMsg(new LocEngUpdateRegistrationMask(
3018 &loc_eng_data,
3019 event,
3020 LOC_REGISTRATION_MASK_DISABLED));
3021 // set up the callback
3022 loc_eng_data.gps_measurement_cb = NULL;
3023 EXIT_LOG(%d, 0);
3024 }
3025