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 {"SUPL_MODE", &gps_conf.SUPL_MODE, NULL, 'n'},
105 {"INTERMEDIATE_POS", &gps_conf.INTERMEDIATE_POS, NULL, 'n'},
106 {"ACCURACY_THRES", &gps_conf.ACCURACY_THRES, NULL, 'n'},
107 {"NMEA_PROVIDER", &gps_conf.NMEA_PROVIDER, NULL, 'n'},
108 {"CAPABILITIES", &gps_conf.CAPABILITIES, NULL, 'n'},
109 {"XTRA_VERSION_CHECK", &gps_conf.XTRA_VERSION_CHECK, NULL, 'n'},
110 {"XTRA_SERVER_1", &gps_conf.XTRA_SERVER_1, NULL, 's'},
111 {"XTRA_SERVER_2", &gps_conf.XTRA_SERVER_2, NULL, 's'},
112 {"XTRA_SERVER_3", &gps_conf.XTRA_SERVER_3, NULL, 's'},
113 {"USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL", &gps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL, NULL, 'n'},
114 };
115
116 static loc_param_s_type sap_conf_table[] =
117 {
118 {"GYRO_BIAS_RANDOM_WALK", &sap_conf.GYRO_BIAS_RANDOM_WALK, &sap_conf.GYRO_BIAS_RANDOM_WALK_VALID, 'f'},
119 {"ACCEL_RANDOM_WALK_SPECTRAL_DENSITY", &sap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY, &sap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY_VALID, 'f'},
120 {"ANGLE_RANDOM_WALK_SPECTRAL_DENSITY", &sap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY, &sap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY_VALID, 'f'},
121 {"RATE_RANDOM_WALK_SPECTRAL_DENSITY", &sap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY, &sap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY_VALID, 'f'},
122 {"VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY", &sap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY, &sap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY_VALID, 'f'},
123 {"SENSOR_ACCEL_BATCHES_PER_SEC", &sap_conf.SENSOR_ACCEL_BATCHES_PER_SEC, NULL, 'n'},
124 {"SENSOR_ACCEL_SAMPLES_PER_BATCH", &sap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH, NULL, 'n'},
125 {"SENSOR_GYRO_BATCHES_PER_SEC", &sap_conf.SENSOR_GYRO_BATCHES_PER_SEC, NULL, 'n'},
126 {"SENSOR_GYRO_SAMPLES_PER_BATCH", &sap_conf.SENSOR_GYRO_SAMPLES_PER_BATCH, NULL, 'n'},
127 {"SENSOR_ACCEL_BATCHES_PER_SEC_HIGH", &sap_conf.SENSOR_ACCEL_BATCHES_PER_SEC_HIGH, NULL, 'n'},
128 {"SENSOR_ACCEL_SAMPLES_PER_BATCH_HIGH", &sap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH_HIGH, NULL, 'n'},
129 {"SENSOR_GYRO_BATCHES_PER_SEC_HIGH", &sap_conf.SENSOR_GYRO_BATCHES_PER_SEC_HIGH, NULL, 'n'},
130 {"SENSOR_GYRO_SAMPLES_PER_BATCH_HIGH", &sap_conf.SENSOR_GYRO_SAMPLES_PER_BATCH_HIGH, NULL, 'n'},
131 {"SENSOR_CONTROL_MODE", &sap_conf.SENSOR_CONTROL_MODE, NULL, 'n'},
132 {"SENSOR_USAGE", &sap_conf.SENSOR_USAGE, NULL, 'n'},
133 {"SENSOR_ALGORITHM_CONFIG_MASK", &sap_conf.SENSOR_ALGORITHM_CONFIG_MASK, NULL, 'n'},
134 {"SENSOR_PROVIDER", &sap_conf.SENSOR_PROVIDER, NULL, 'n'}
135 };
136
loc_default_parameters(void)137 static void loc_default_parameters(void)
138 {
139 /*Defaults for gps.conf*/
140 gps_conf.INTERMEDIATE_POS = 0;
141 gps_conf.ACCURACY_THRES = 0;
142 gps_conf.NMEA_PROVIDER = 0;
143 gps_conf.GPS_LOCK = 0;
144 gps_conf.SUPL_VER = 0x10000;
145 gps_conf.SUPL_MODE = 0x3;
146 gps_conf.CAPABILITIES = 0x7;
147 /* LTE Positioning Profile configuration is disable by default*/
148 gps_conf.LPP_PROFILE = 0;
149 /*By default no positioning protocol is selected on A-GLONASS system*/
150 gps_conf.A_GLONASS_POS_PROTOCOL_SELECT = 0;
151 /*XTRA version check is disabled by default*/
152 gps_conf.XTRA_VERSION_CHECK=0;
153 /*Use emergency PDN by default*/
154 gps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL = 1;
155
156 /*Defaults for sap.conf*/
157 sap_conf.GYRO_BIAS_RANDOM_WALK = 0;
158 sap_conf.SENSOR_ACCEL_BATCHES_PER_SEC = 2;
159 sap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH = 5;
160 sap_conf.SENSOR_GYRO_BATCHES_PER_SEC = 2;
161 sap_conf.SENSOR_GYRO_SAMPLES_PER_BATCH = 5;
162 sap_conf.SENSOR_ACCEL_BATCHES_PER_SEC_HIGH = 4;
163 sap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH_HIGH = 25;
164 sap_conf.SENSOR_GYRO_BATCHES_PER_SEC_HIGH = 4;
165 sap_conf.SENSOR_GYRO_SAMPLES_PER_BATCH_HIGH = 25;
166 sap_conf.SENSOR_CONTROL_MODE = 0; /* AUTO */
167 sap_conf.SENSOR_USAGE = 0; /* Enabled */
168 sap_conf.SENSOR_ALGORITHM_CONFIG_MASK = 0; /* INS Disabled = FALSE*/
169 /* Values MUST be set by OEMs in configuration for sensor-assisted
170 navigation to work. There are NO default values */
171 sap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY = 0;
172 sap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY = 0;
173 sap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY = 0;
174 sap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY = 0;
175 sap_conf.GYRO_BIAS_RANDOM_WALK_VALID = 0;
176 sap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY_VALID = 0;
177 sap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY_VALID = 0;
178 sap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY_VALID = 0;
179 sap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY_VALID = 0;
180 /* default provider is SSC */
181 sap_conf.SENSOR_PROVIDER = 1;
182
183 /* None of the 10 slots for agps certificates are writable by default */
184 gps_conf.AGPS_CERT_WRITABLE_MASK = 0;
185 }
186
187 // 2nd half of init(), singled out for
188 // modem restart to use.
189 static int loc_eng_reinit(loc_eng_data_s_type &loc_eng_data);
190 static void loc_eng_agps_reinit(loc_eng_data_s_type &loc_eng_data);
191
192 static int loc_eng_set_server(loc_eng_data_s_type &loc_eng_data,
193 LocServerType type, const char *hostname, int port);
194 // Internal functions
195 static void loc_inform_gps_status(loc_eng_data_s_type &loc_eng_data,
196 GpsStatusValue status);
197 static void loc_eng_report_status(loc_eng_data_s_type &loc_eng_data,
198 GpsStatusValue status);
199 static void loc_eng_process_conn_request(loc_eng_data_s_type &loc_eng_data,
200 int connHandle, AGpsType agps_type);
201 static void loc_eng_agps_close_status(loc_eng_data_s_type &loc_eng_data, int is_succ);
202 static void loc_eng_handle_engine_down(loc_eng_data_s_type &loc_eng_data) ;
203 static void loc_eng_handle_engine_up(loc_eng_data_s_type &loc_eng_data) ;
204
205 static int loc_eng_start_handler(loc_eng_data_s_type &loc_eng_data);
206 static int loc_eng_stop_handler(loc_eng_data_s_type &loc_eng_data);
207 static int loc_eng_get_zpp_handler(loc_eng_data_s_type &loc_eng_data);
208 static void deleteAidingData(loc_eng_data_s_type &logEng);
209 static AgpsStateMachine*
210 getAgpsStateMachine(loc_eng_data_s_type& logEng, AGpsExtType agpsType);
211 static int dataCallCb(void *cb_data);
update_aiding_data_for_deletion(loc_eng_data_s_type & loc_eng_data)212 static void update_aiding_data_for_deletion(loc_eng_data_s_type& loc_eng_data) {
213 if (loc_eng_data.engine_status != GPS_STATUS_ENGINE_ON &&
214 loc_eng_data.aiding_data_for_deletion != 0)
215 {
216 loc_eng_data.adapter->deleteAidingData(loc_eng_data.aiding_data_for_deletion);
217 loc_eng_data.aiding_data_for_deletion = 0;
218 }
219 }
220
noProc(void * data)221 static void* noProc(void* data)
222 {
223 return NULL;
224 }
225
226
227 /*********************************************************************
228 * definitions of the static messages used in the file
229 *********************************************************************/
230 // case LOC_ENG_MSG_REQUEST_NI:
LocEngRequestNi(void * locEng,GpsNiNotification & notif,const void * data)231 LocEngRequestNi::LocEngRequestNi(void* locEng,
232 GpsNiNotification ¬if,
233 const void* data) :
234 LocMsg(), mLocEng(locEng), mNotify(notif), mPayload(data) {
235 locallog();
236 }
proc() const237 void LocEngRequestNi::proc() const {
238 loc_eng_ni_request_handler(*((loc_eng_data_s_type*)mLocEng),
239 &mNotify, mPayload);
240 }
locallog() const241 void LocEngRequestNi::locallog() const
242 {
243 LOC_LOGV("id: %d\n type: %s\n flags: %d\n time out: %d\n "
244 "default response: %s\n requestor id encoding: %s\n"
245 " text encoding: %s\n passThroughData: %p",
246 mNotify.notification_id,
247 loc_get_ni_type_name(mNotify.ni_type),
248 mNotify.notify_flags,
249 mNotify.timeout,
250 loc_get_ni_response_name(mNotify.default_response),
251 loc_get_ni_encoding_name(mNotify.requestor_id_encoding),
252 loc_get_ni_encoding_name(mNotify.text_encoding),
253 mPayload);
254 }
log() const255 inline void LocEngRequestNi::log() const {
256 locallog();
257 }
258
259 // case LOC_ENG_MSG_INFORM_NI_RESPONSE:
260 // in loc_eng_ni.cpp
261
262 // case LOC_ENG_MSG_START_FIX:
LocEngStartFix(LocEngAdapter * adapter)263 LocEngStartFix::LocEngStartFix(LocEngAdapter* adapter) :
264 LocMsg(), mAdapter(adapter)
265 {
266 locallog();
267 }
proc() const268 inline void LocEngStartFix::proc() const
269 {
270 loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mAdapter->getOwner();
271 loc_eng_start_handler(*locEng);
272 }
locallog() const273 inline void LocEngStartFix::locallog() const
274 {
275 LOC_LOGV("LocEngStartFix");
276 }
log() const277 inline void LocEngStartFix::log() const
278 {
279 locallog();
280 }
send() const281 void LocEngStartFix::send() const {
282 mAdapter->sendMsg(this);
283 }
284
285 // case LOC_ENG_MSG_STOP_FIX:
LocEngStopFix(LocEngAdapter * adapter)286 LocEngStopFix::LocEngStopFix(LocEngAdapter* adapter) :
287 LocMsg(), mAdapter(adapter)
288 {
289 locallog();
290 }
proc() const291 inline void LocEngStopFix::proc() const
292 {
293 loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mAdapter->getOwner();
294 loc_eng_stop_handler(*locEng);
295 }
locallog() const296 inline void LocEngStopFix::locallog() const
297 {
298 LOC_LOGV("LocEngStopFix");
299 }
log() const300 inline void LocEngStopFix::log() const
301 {
302 locallog();
303 }
send() const304 void LocEngStopFix::send() const {
305 mAdapter->sendMsg(this);
306 }
307
308 // case LOC_ENG_MSG_SET_POSITION_MODE:
LocEngPositionMode(LocEngAdapter * adapter,LocPosMode & mode)309 LocEngPositionMode::LocEngPositionMode(LocEngAdapter* adapter,
310 LocPosMode &mode) :
311 LocMsg(), mAdapter(adapter), mPosMode(mode)
312 {
313 mPosMode.logv();
314 }
proc() const315 inline void LocEngPositionMode::proc() const {
316 mAdapter->setPositionMode(&mPosMode);
317 }
log() const318 inline void LocEngPositionMode::log() const {
319 mPosMode.logv();
320 }
send() const321 void LocEngPositionMode::send() const {
322 mAdapter->sendMsg(this);
323 }
324
LocEngGetZpp(LocEngAdapter * adapter)325 LocEngGetZpp::LocEngGetZpp(LocEngAdapter* adapter) :
326 LocMsg(), mAdapter(adapter)
327 {
328 locallog();
329 }
proc() const330 inline void LocEngGetZpp::proc() const
331 {
332 loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mAdapter->getOwner();
333 loc_eng_get_zpp_handler(*locEng);
334 }
locallog() const335 inline void LocEngGetZpp::locallog() const
336 {
337 LOC_LOGV("LocEngGetZpp");
338 }
log() const339 inline void LocEngGetZpp::log() const
340 {
341 locallog();
342 }
send() const343 void LocEngGetZpp::send() const {
344 mAdapter->sendMsg(this);
345 }
346
347 struct LocEngSetTime : public LocMsg {
348 LocEngAdapter* mAdapter;
349 const GpsUtcTime mTime;
350 const int64_t mTimeReference;
351 const int mUncertainty;
LocEngSetTimeLocEngSetTime352 inline LocEngSetTime(LocEngAdapter* adapter,
353 GpsUtcTime t, int64_t tf, int unc) :
354 LocMsg(), mAdapter(adapter),
355 mTime(t), mTimeReference(tf), mUncertainty(unc)
356 {
357 locallog();
358 }
procLocEngSetTime359 inline virtual void proc() const {
360 mAdapter->setTime(mTime, mTimeReference, mUncertainty);
361 }
locallogLocEngSetTime362 inline void locallog() const {
363 LOC_LOGV("time: %lld\n timeReference: %lld\n uncertainty: %d",
364 mTime, mTimeReference, mUncertainty);
365 }
logLocEngSetTime366 inline virtual void log() const {
367 locallog();
368 }
369 };
370
371 // case LOC_ENG_MSG_INJECT_LOCATION:
372 struct LocEngInjectLocation : public LocMsg {
373 LocEngAdapter* mAdapter;
374 const double mLatitude;
375 const double mLongitude;
376 const float mAccuracy;
LocEngInjectLocationLocEngInjectLocation377 inline LocEngInjectLocation(LocEngAdapter* adapter,
378 double lat, double lon, float accur) :
379 LocMsg(), mAdapter(adapter),
380 mLatitude(lat), mLongitude(lon), mAccuracy(accur)
381 {
382 locallog();
383 }
procLocEngInjectLocation384 inline virtual void proc() const {
385 mAdapter->injectPosition(mLatitude, mLongitude, mAccuracy);
386 }
locallogLocEngInjectLocation387 inline void locallog() const {
388 LOC_LOGV("latitude: %f\n longitude: %f\n accuracy: %f",
389 mLatitude, mLongitude, mAccuracy);
390 }
logLocEngInjectLocation391 inline virtual void log() const {
392 locallog();
393 }
394 };
395
396 // case LOC_ENG_MSG_SET_SERVER_IPV4:
397 struct LocEngSetServerIpv4 : public LocMsg {
398 LocEngAdapter* mAdapter;
399 const unsigned int mNlAddr;
400 const int mPort;
401 const LocServerType mServerType;
LocEngSetServerIpv4LocEngSetServerIpv4402 inline LocEngSetServerIpv4(LocEngAdapter* adapter,
403 unsigned int ip,
404 int port,
405 LocServerType type) :
406 LocMsg(), mAdapter(adapter),
407 mNlAddr(ip), mPort(port), mServerType(type)
408 {
409 locallog();
410 }
procLocEngSetServerIpv4411 inline virtual void proc() const {
412 mAdapter->setServer(mNlAddr, mPort, mServerType);
413 }
locallogLocEngSetServerIpv4414 inline void locallog() const {
415 LOC_LOGV("LocEngSetServerIpv4 - addr: %x, port: %d, type: %s",
416 mNlAddr, mPort, loc_get_server_type_name(mServerType));
417 }
logLocEngSetServerIpv4418 inline virtual void log() const {
419 locallog();
420 }
421 };
422
423 // case LOC_ENG_MSG_SET_SERVER_URL:
424 struct LocEngSetServerUrl : public LocMsg {
425 LocEngAdapter* mAdapter;
426 const int mLen;
427 char* mUrl;
LocEngSetServerUrlLocEngSetServerUrl428 inline LocEngSetServerUrl(LocEngAdapter* adapter,
429 char* urlString,
430 int url_len) :
431 LocMsg(), mAdapter(adapter),
432 mLen(url_len), mUrl(new char[mLen+1])
433 {
434 memcpy((void*)mUrl, (void*)urlString, url_len);
435 mUrl[mLen] = 0;
436 locallog();
437 }
~LocEngSetServerUrlLocEngSetServerUrl438 inline ~LocEngSetServerUrl()
439 {
440 delete[] mUrl;
441 }
procLocEngSetServerUrl442 inline virtual void proc() const {
443 mAdapter->setServer(mUrl, mLen);
444 }
locallogLocEngSetServerUrl445 inline void locallog() const {
446 LOC_LOGV("LocEngSetServerUrl - url: %s", mUrl);
447 }
logLocEngSetServerUrl448 inline virtual void log() const {
449 locallog();
450 }
451 };
452
453 // case LOC_ENG_MSG_A_GLONASS_PROTOCOL:
454 struct LocEngAGlonassProtocol : public LocMsg {
455 LocEngAdapter* mAdapter;
456 const unsigned long mAGlonassProtocl;
LocEngAGlonassProtocolLocEngAGlonassProtocol457 inline LocEngAGlonassProtocol(LocEngAdapter* adapter,
458 unsigned long protocol) :
459 LocMsg(), mAdapter(adapter), mAGlonassProtocl(protocol)
460 {
461 locallog();
462 }
procLocEngAGlonassProtocol463 inline virtual void proc() const {
464 mAdapter->setAGLONASSProtocol(mAGlonassProtocl);
465 }
locallogLocEngAGlonassProtocol466 inline void locallog() const {
467 LOC_LOGV("A-GLONASS protocol: 0x%lx", mAGlonassProtocl);
468 }
logLocEngAGlonassProtocol469 inline virtual void log() const {
470 locallog();
471 }
472 };
473
474 // case LOC_ENG_MSG_SUPL_VERSION:
475 struct LocEngSuplVer : public LocMsg {
476 LocEngAdapter* mAdapter;
477 const int mSuplVer;
LocEngSuplVerLocEngSuplVer478 inline LocEngSuplVer(LocEngAdapter* adapter,
479 int suplVer) :
480 LocMsg(), mAdapter(adapter), mSuplVer(suplVer)
481 {
482 locallog();
483 }
procLocEngSuplVer484 inline virtual void proc() const {
485 mAdapter->setSUPLVersion(mSuplVer);
486 }
locallogLocEngSuplVer487 inline void locallog() const {
488 LOC_LOGV("SUPL Version: %d", mSuplVer);
489 }
logLocEngSuplVer490 inline virtual void log() const {
491 locallog();
492 }
493 };
494
495 struct LocEngSuplMode : public LocMsg {
496 UlpProxyBase* mUlp;
497
LocEngSuplModeLocEngSuplMode498 inline LocEngSuplMode(UlpProxyBase* ulp) :
499 LocMsg(), mUlp(ulp)
500 {
501 locallog();
502 }
procLocEngSuplMode503 inline virtual void proc() const {
504 mUlp->setCapabilities(getCarrierCapabilities());
505 }
locallogLocEngSuplMode506 inline void locallog() const {
507 }
logLocEngSuplMode508 inline virtual void log() const {
509 locallog();
510 }
511 };
512
513 // case LOC_ENG_MSG_LPP_CONFIG:
514 struct LocEngLppConfig : public LocMsg {
515 LocEngAdapter* mAdapter;
516 const int mLppConfig;
LocEngLppConfigLocEngLppConfig517 inline LocEngLppConfig(LocEngAdapter* adapter,
518 int lppConfig) :
519 LocMsg(), mAdapter(adapter), mLppConfig(lppConfig)
520 {
521 locallog();
522 }
procLocEngLppConfig523 inline virtual void proc() const {
524 mAdapter->setLPPConfig(mLppConfig);
525 }
locallogLocEngLppConfig526 inline void locallog() const {
527 LOC_LOGV("LocEngLppConfig - profile: %d", mLppConfig);
528 }
logLocEngLppConfig529 inline virtual void log() const {
530 locallog();
531 }
532 };
533
534 // case LOC_ENG_MSG_SET_SENSOR_CONTROL_CONFIG:
535 struct LocEngSensorControlConfig : public LocMsg {
536 LocEngAdapter* mAdapter;
537 const int mSensorsDisabled;
538 const int mSensorProvider;
LocEngSensorControlConfigLocEngSensorControlConfig539 inline LocEngSensorControlConfig(LocEngAdapter* adapter,
540 int sensorsDisabled, int sensorProvider) :
541 LocMsg(), mAdapter(adapter), mSensorsDisabled(sensorsDisabled),
542 mSensorProvider(sensorProvider)
543 {
544 locallog();
545 }
procLocEngSensorControlConfig546 inline virtual void proc() const {
547 mAdapter->setSensorControlConfig(mSensorsDisabled, mSensorProvider);
548 }
locallogLocEngSensorControlConfig549 inline void locallog() const {
550 LOC_LOGV("LocEngSensorControlConfig - Sensors Disabled: %d, Sensor Provider: %d",
551 mSensorsDisabled, mSensorProvider);
552 }
logLocEngSensorControlConfig553 inline virtual void log() const {
554 locallog();
555 }
556 };
557
558 // case LOC_ENG_MSG_SET_SENSOR_PROPERTIES:
559 struct LocEngSensorProperties : public LocMsg {
560 LocEngAdapter* mAdapter;
561 const bool mGyroBiasVarianceRandomWalkValid;
562 const float mGyroBiasVarianceRandomWalk;
563 const bool mAccelRandomWalkValid;
564 const float mAccelRandomWalk;
565 const bool mAngleRandomWalkValid;
566 const float mAngleRandomWalk;
567 const bool mRateRandomWalkValid;
568 const float mRateRandomWalk;
569 const bool mVelocityRandomWalkValid;
570 const float mVelocityRandomWalk;
LocEngSensorPropertiesLocEngSensorProperties571 inline LocEngSensorProperties(LocEngAdapter* adapter,
572 bool gyroBiasRandomWalk_valid,
573 float gyroBiasRandomWalk,
574 bool accelRandomWalk_valid,
575 float accelRandomWalk,
576 bool angleRandomWalk_valid,
577 float angleRandomWalk,
578 bool rateRandomWalk_valid,
579 float rateRandomWalk,
580 bool velocityRandomWalk_valid,
581 float velocityRandomWalk) :
582 LocMsg(), mAdapter(adapter),
583 mGyroBiasVarianceRandomWalkValid(gyroBiasRandomWalk_valid),
584 mGyroBiasVarianceRandomWalk(gyroBiasRandomWalk),
585 mAccelRandomWalkValid(accelRandomWalk_valid),
586 mAccelRandomWalk(accelRandomWalk),
587 mAngleRandomWalkValid(angleRandomWalk_valid),
588 mAngleRandomWalk(angleRandomWalk),
589 mRateRandomWalkValid(rateRandomWalk_valid),
590 mRateRandomWalk(rateRandomWalk),
591 mVelocityRandomWalkValid(velocityRandomWalk_valid),
592 mVelocityRandomWalk(velocityRandomWalk)
593 {
594 locallog();
595 }
procLocEngSensorProperties596 inline virtual void proc() const {
597 mAdapter->setSensorProperties(mGyroBiasVarianceRandomWalkValid,
598 mGyroBiasVarianceRandomWalk,
599 mAccelRandomWalkValid,
600 mAccelRandomWalk,
601 mAngleRandomWalkValid,
602 mAngleRandomWalk,
603 mRateRandomWalkValid,
604 mRateRandomWalk,
605 mVelocityRandomWalkValid,
606 mVelocityRandomWalk);
607 }
locallogLocEngSensorProperties608 inline void locallog() const {
609 LOC_LOGV("Sensor properties validity, Gyro Random walk: %d "
610 "Accel Random Walk: %d "
611 "Angle Random Walk: %d Rate Random Walk: %d "
612 "Velocity Random Walk: %d\n"
613 "Sensor properties, Gyro Random walk: %f "
614 "Accel Random Walk: %f "
615 "Angle Random Walk: %f Rate Random Walk: %f "
616 "Velocity Random Walk: %f",
617 mGyroBiasVarianceRandomWalkValid,
618 mAccelRandomWalkValid,
619 mAngleRandomWalkValid,
620 mRateRandomWalkValid,
621 mVelocityRandomWalkValid,
622 mGyroBiasVarianceRandomWalk,
623 mAccelRandomWalk,
624 mAngleRandomWalk,
625 mRateRandomWalk,
626 mVelocityRandomWalk
627 );
628 }
logLocEngSensorProperties629 inline virtual void log() const {
630 locallog();
631 }
632 };
633
634 // case LOC_ENG_MSG_SET_SENSOR_PERF_CONTROL_CONFIG:
635 struct LocEngSensorPerfControlConfig : public LocMsg {
636 LocEngAdapter* mAdapter;
637 const int mControlMode;
638 const int mAccelSamplesPerBatch;
639 const int mAccelBatchesPerSec;
640 const int mGyroSamplesPerBatch;
641 const int mGyroBatchesPerSec;
642 const int mAccelSamplesPerBatchHigh;
643 const int mAccelBatchesPerSecHigh;
644 const int mGyroSamplesPerBatchHigh;
645 const int mGyroBatchesPerSecHigh;
646 const int mAlgorithmConfig;
LocEngSensorPerfControlConfigLocEngSensorPerfControlConfig647 inline LocEngSensorPerfControlConfig(LocEngAdapter* adapter,
648 int controlMode,
649 int accelSamplesPerBatch,
650 int accelBatchesPerSec,
651 int gyroSamplesPerBatch,
652 int gyroBatchesPerSec,
653 int accelSamplesPerBatchHigh,
654 int accelBatchesPerSecHigh,
655 int gyroSamplesPerBatchHigh,
656 int gyroBatchesPerSecHigh,
657 int algorithmConfig) :
658 LocMsg(), mAdapter(adapter),
659 mControlMode(controlMode),
660 mAccelSamplesPerBatch(accelSamplesPerBatch),
661 mAccelBatchesPerSec(accelBatchesPerSec),
662 mGyroSamplesPerBatch(gyroSamplesPerBatch),
663 mGyroBatchesPerSec(gyroBatchesPerSec),
664 mAccelSamplesPerBatchHigh(accelSamplesPerBatchHigh),
665 mAccelBatchesPerSecHigh(accelBatchesPerSecHigh),
666 mGyroSamplesPerBatchHigh(gyroSamplesPerBatchHigh),
667 mGyroBatchesPerSecHigh(gyroBatchesPerSecHigh),
668 mAlgorithmConfig(algorithmConfig)
669 {
670 locallog();
671 }
procLocEngSensorPerfControlConfig672 inline virtual void proc() const {
673 mAdapter->setSensorPerfControlConfig(mControlMode,
674 mAccelSamplesPerBatch,
675 mAccelBatchesPerSec,
676 mGyroSamplesPerBatch,
677 mGyroBatchesPerSec,
678 mAccelSamplesPerBatchHigh,
679 mAccelBatchesPerSecHigh,
680 mGyroSamplesPerBatchHigh,
681 mGyroBatchesPerSecHigh,
682 mAlgorithmConfig);
683 }
locallogLocEngSensorPerfControlConfig684 inline void locallog() const {
685 LOC_LOGV("Sensor Perf Control Config (performanceControlMode)(%u) "
686 "accel(#smp,#batches) (%u,%u) "
687 "gyro(#smp,#batches) (%u,%u), "
688 "accel_high(#smp,#batches) (%u,%u) "
689 "gyro_high(#smp,#batches) (%u,%u), "
690 "algorithmConfig(%u)\n",
691 mControlMode,
692 mAccelSamplesPerBatch, mAccelBatchesPerSec,
693 mGyroSamplesPerBatch, mGyroBatchesPerSec,
694 mAccelSamplesPerBatchHigh, mAccelBatchesPerSecHigh,
695 mGyroSamplesPerBatchHigh, mGyroBatchesPerSecHigh,
696 mAlgorithmConfig);
697 }
logLocEngSensorPerfControlConfig698 inline virtual void log() const {
699 locallog();
700 }
701 };
702
703 // case LOC_ENG_MSG_EXT_POWER_CONFIG:
704 struct LocEngExtPowerConfig : public LocMsg {
705 LocEngAdapter* mAdapter;
706 const int mIsBatteryCharging;
LocEngExtPowerConfigLocEngExtPowerConfig707 inline LocEngExtPowerConfig(LocEngAdapter* adapter,
708 int isBatteryCharging) :
709 LocMsg(), mAdapter(adapter),
710 mIsBatteryCharging(isBatteryCharging)
711 {
712 locallog();
713 }
procLocEngExtPowerConfig714 inline virtual void proc() const {
715 mAdapter->setExtPowerConfig(mIsBatteryCharging);
716 }
locallogLocEngExtPowerConfig717 inline void locallog() const {
718 LOC_LOGV("LocEngExtPowerConfig - isBatteryCharging: %d",
719 mIsBatteryCharging);
720 }
logLocEngExtPowerConfig721 inline virtual void log() const {
722 locallog();
723 }
724 };
725
726 // case LOC_ENG_MSG_REPORT_POSITION:
LocEngReportPosition(LocAdapterBase * adapter,UlpLocation & loc,GpsLocationExtended & locExtended,void * locExt,enum loc_sess_status st,LocPosTechMask technology)727 LocEngReportPosition::LocEngReportPosition(LocAdapterBase* adapter,
728 UlpLocation &loc,
729 GpsLocationExtended &locExtended,
730 void* locExt,
731 enum loc_sess_status st,
732 LocPosTechMask technology) :
733 LocMsg(), mAdapter(adapter), mLocation(loc),
734 mLocationExtended(locExtended),
735 mLocationExt(((loc_eng_data_s_type*)
736 ((LocEngAdapter*)
737 (mAdapter))->getOwner())->location_ext_parser(locExt)),
738 mStatus(st), mTechMask(technology)
739 {
740 locallog();
741 }
proc() const742 void LocEngReportPosition::proc() const {
743 LocEngAdapter* adapter = (LocEngAdapter*)mAdapter;
744 loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)adapter->getOwner();
745
746 if (locEng->mute_session_state != LOC_MUTE_SESS_IN_SESSION) {
747 bool reported = false;
748 if (locEng->location_cb != NULL) {
749 if (LOC_SESS_FAILURE == mStatus) {
750 // in case we want to handle the failure case
751 locEng->location_cb(NULL, NULL);
752 reported = true;
753 }
754 // what's in the else if is... (line by line)
755 // 1. this is a final fix; and
756 // 1.1 it is a Satellite fix; or
757 // 1.2 it is a sensor fix
758 // 2. (must be intermediate fix... implicit)
759 // 2.1 we accepte intermediate; and
760 // 2.2 it is NOT the case that
761 // 2.2.1 there is inaccuracy; and
762 // 2.2.2 we care about inaccuracy; and
763 // 2.2.3 the inaccuracy exceeds our tolerance
764 else if ((LOC_SESS_SUCCESS == mStatus &&
765 ((LOC_POS_TECH_MASK_SATELLITE |
766 LOC_POS_TECH_MASK_SENSORS |
767 LOC_POS_TECH_MASK_HYBRID) &
768 mTechMask)) ||
769 (LOC_SESS_INTERMEDIATE == locEng->intermediateFix &&
770 !((mLocation.gpsLocation.flags &
771 GPS_LOCATION_HAS_ACCURACY) &&
772 (gps_conf.ACCURACY_THRES != 0) &&
773 (mLocation.gpsLocation.accuracy >
774 gps_conf.ACCURACY_THRES)))) {
775 locEng->location_cb((UlpLocation*)&(mLocation),
776 (void*)mLocationExt);
777 reported = true;
778 }
779 }
780
781 // if we have reported this fix
782 if (reported &&
783 // and if this is a singleshot
784 GPS_POSITION_RECURRENCE_SINGLE ==
785 locEng->adapter->getPositionMode().recurrence) {
786 if (LOC_SESS_INTERMEDIATE == mStatus) {
787 // modem could be still working for a final fix,
788 // although we no longer need it. So stopFix().
789 locEng->adapter->stopFix();
790 }
791 // turn off the session flag.
792 locEng->adapter->setInSession(false);
793 }
794
795 if (locEng->generateNmea &&
796 mLocation.position_source == ULP_LOCATION_IS_FROM_GNSS &&
797 mTechMask & (LOC_POS_TECH_MASK_SATELLITE |
798 LOC_POS_TECH_MASK_SENSORS |
799 LOC_POS_TECH_MASK_HYBRID))
800 {
801 unsigned char generate_nmea = reported &&
802 (mStatus != LOC_SESS_FAILURE);
803 loc_eng_nmea_generate_pos(locEng, mLocation, mLocationExtended,
804 generate_nmea);
805 }
806
807 // Free the allocated memory for rawData
808 UlpLocation* gp = (UlpLocation*)&(mLocation);
809 if (gp != NULL && gp->rawData != NULL)
810 {
811 delete (char*)gp->rawData;
812 gp->rawData = NULL;
813 gp->rawDataSize = 0;
814 }
815 }
816 }
locallog() const817 void LocEngReportPosition::locallog() const {
818 LOC_LOGV("LocEngReportPosition");
819 }
log() const820 void LocEngReportPosition::log() const {
821 locallog();
822 }
send() const823 void LocEngReportPosition::send() const {
824 mAdapter->sendMsg(this);
825 }
826
827
828 // case LOC_ENG_MSG_REPORT_SV:
LocEngReportSv(LocAdapterBase * adapter,GpsSvStatus & sv,GpsLocationExtended & locExtended,void * svExt)829 LocEngReportSv::LocEngReportSv(LocAdapterBase* adapter,
830 GpsSvStatus &sv,
831 GpsLocationExtended &locExtended,
832 void* svExt) :
833 LocMsg(), mAdapter(adapter), mSvStatus(sv),
834 mLocationExtended(locExtended),
835 mSvExt(((loc_eng_data_s_type*)
836 ((LocEngAdapter*)
837 (mAdapter))->getOwner())->sv_ext_parser(svExt))
838 {
839 locallog();
840 }
proc() const841 void LocEngReportSv::proc() const {
842 LocEngAdapter* adapter = (LocEngAdapter*)mAdapter;
843 loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)adapter->getOwner();
844
845 if (locEng->mute_session_state != LOC_MUTE_SESS_IN_SESSION)
846 {
847 if (locEng->sv_status_cb != NULL) {
848 locEng->sv_status_cb((GpsSvStatus*)&(mSvStatus),
849 (void*)mSvExt);
850 }
851
852 if (locEng->generateNmea)
853 {
854 loc_eng_nmea_generate_sv(locEng, mSvStatus, mLocationExtended);
855 }
856 }
857 }
locallog() const858 void LocEngReportSv::locallog() const {
859 LOC_LOGV("%s:%d] LocEngReportSv",__func__, __LINE__);
860 }
log() const861 inline void LocEngReportSv::log() const {
862 locallog();
863 }
send() const864 void LocEngReportSv::send() const {
865 mAdapter->sendMsg(this);
866 }
867
868 // case LOC_ENG_MSG_REPORT_STATUS:
LocEngReportStatus(LocAdapterBase * adapter,GpsStatusValue engineStatus)869 LocEngReportStatus::LocEngReportStatus(LocAdapterBase* adapter,
870 GpsStatusValue engineStatus) :
871 LocMsg(), mAdapter(adapter), mStatus(engineStatus)
872 {
873 locallog();
874 }
proc() const875 inline void LocEngReportStatus::proc() const
876 {
877 LocEngAdapter* adapter = (LocEngAdapter*)mAdapter;
878 loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)adapter->getOwner();
879
880 loc_eng_report_status(*locEng, mStatus);
881 update_aiding_data_for_deletion(*locEng);
882 }
locallog() const883 inline void LocEngReportStatus::locallog() const {
884 LOC_LOGV("LocEngReportStatus");
885 }
log() const886 inline void LocEngReportStatus::log() const {
887 locallog();
888 }
889
890 // case LOC_ENG_MSG_REPORT_NMEA:
LocEngReportNmea(void * locEng,const char * data,int len)891 LocEngReportNmea::LocEngReportNmea(void* locEng,
892 const char* data, int len) :
893 LocMsg(), mLocEng(locEng), mNmea(new char[len]), mLen(len)
894 {
895 memcpy((void*)mNmea, (void*)data, len);
896 locallog();
897 }
proc() const898 void LocEngReportNmea::proc() const {
899 loc_eng_data_s_type* locEng = (loc_eng_data_s_type*) mLocEng;
900
901 struct timeval tv;
902 gettimeofday(&tv, (struct timezone *) NULL);
903 int64_t now = tv.tv_sec * 1000LL + tv.tv_usec / 1000;
904
905 if (locEng->nmea_cb != NULL)
906 locEng->nmea_cb(now, mNmea, mLen);
907 }
locallog() const908 inline void LocEngReportNmea::locallog() const {
909 LOC_LOGV("LocEngReportNmea");
910 }
log() const911 inline void LocEngReportNmea::log() const {
912 locallog();
913 }
914
915 // case LOC_ENG_MSG_REPORT_XTRA_SERVER:
LocEngReportXtraServer(void * locEng,const char * url1,const char * url2,const char * url3,const int maxlength)916 LocEngReportXtraServer::LocEngReportXtraServer(void* locEng,
917 const char *url1,
918 const char *url2,
919 const char *url3,
920 const int maxlength) :
921 LocMsg(), mLocEng(locEng), mMaxLen(maxlength),
922 mServers(new char[3*(mMaxLen+1)])
923 {
924 char * cptr = mServers;
925 memset(mServers, 0, 3*(mMaxLen+1));
926
927 // Override modem URLs with uncommented gps.conf urls
928 if( gps_conf.XTRA_SERVER_1[0] != '\0' ) {
929 url1 = &gps_conf.XTRA_SERVER_1[0];
930 }
931 if( gps_conf.XTRA_SERVER_2[0] != '\0' ) {
932 url2 = &gps_conf.XTRA_SERVER_2[0];
933 }
934 if( gps_conf.XTRA_SERVER_3[0] != '\0' ) {
935 url3 = &gps_conf.XTRA_SERVER_3[0];
936 }
937 // copy non xtra1.gpsonextra.net URLs into the forwarding buffer.
938 if( NULL == strcasestr(url1, XTRA1_GPSONEXTRA) ) {
939 strlcpy(cptr, url1, mMaxLen + 1);
940 cptr += mMaxLen + 1;
941 }
942 if( NULL == strcasestr(url2, XTRA1_GPSONEXTRA) ) {
943 strlcpy(cptr, url2, mMaxLen + 1);
944 cptr += mMaxLen + 1;
945 }
946 if( NULL == strcasestr(url3, XTRA1_GPSONEXTRA) ) {
947 strlcpy(cptr, url3, mMaxLen + 1);
948 }
949 locallog();
950 }
951
proc() const952 void LocEngReportXtraServer::proc() const {
953 loc_eng_xtra_data_s_type* locEngXtra =
954 &(((loc_eng_data_s_type*)mLocEng)->xtra_module_data);
955
956 if (locEngXtra->report_xtra_server_cb != NULL) {
957 CALLBACK_LOG_CALLFLOW("report_xtra_server_cb", %s, mServers);
958 locEngXtra->report_xtra_server_cb(mServers,
959 &(mServers[mMaxLen+1]),
960 &(mServers[(mMaxLen+1)<<1]));
961 } else {
962 LOC_LOGE("Callback function for request xtra is NULL");
963 }
964 }
locallog() const965 inline void LocEngReportXtraServer::locallog() const {
966 LOC_LOGV("LocEngReportXtraServers: server1: %s\n server2: %s\n"
967 " server3: %s\n",
968 mServers, &mServers[mMaxLen+1], &mServers[(mMaxLen+1)<<1]);
969 }
log() const970 inline void LocEngReportXtraServer::log() const {
971 locallog();
972 }
973
974 // case LOC_ENG_MSG_REQUEST_BIT:
975 // case LOC_ENG_MSG_RELEASE_BIT:
LocEngReqRelBIT(void * locEng,AGpsExtType type,int ipv4,char * ipv6,bool isReq)976 LocEngReqRelBIT::LocEngReqRelBIT(void* locEng, AGpsExtType type,
977 int ipv4, char* ipv6, bool isReq) :
978 LocMsg(), mLocEng(locEng), mType(type), mIPv4Addr(ipv4),
979 mIPv6Addr(ipv6 ? new char[16] : NULL), mIsReq(isReq) {
980 if (NULL != ipv6)
981 memcpy(mIPv6Addr, ipv6, 16);
982 locallog();
983 }
~LocEngReqRelBIT()984 inline LocEngReqRelBIT::~LocEngReqRelBIT() {
985 if (mIPv6Addr) {
986 delete[] mIPv6Addr;
987 }
988 }
proc() const989 void LocEngReqRelBIT::proc() const {
990 loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
991 BITSubscriber s(getAgpsStateMachine(*locEng, mType),
992 mIPv4Addr, mIPv6Addr);
993 AgpsStateMachine* sm = (AgpsStateMachine*)s.mStateMachine;
994
995 if (mIsReq) {
996 sm->subscribeRsrc((Subscriber*)&s);
997 } else {
998 sm->unsubscribeRsrc((Subscriber*)&s);
999 }
1000 }
locallog() const1001 inline void LocEngReqRelBIT::locallog() const {
1002 LOC_LOGV("LocEngRequestBIT - ipv4: %d.%d.%d.%d, ipv6: %s",
1003 (unsigned char)mIPv4Addr,
1004 (unsigned char)(mIPv4Addr>>8),
1005 (unsigned char)(mIPv4Addr>>16),
1006 (unsigned char)(mIPv4Addr>>24),
1007 NULL != mIPv6Addr ? mIPv6Addr : "");
1008 }
log() const1009 inline void LocEngReqRelBIT::log() const {
1010 locallog();
1011 }
send() const1012 void LocEngReqRelBIT::send() const {
1013 loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
1014 locEng->adapter->sendMsg(this);
1015 }
1016
1017 // case LOC_ENG_MSG_RELEASE_BIT:
1018 struct LocEngReleaseBIT : public LocMsg {
1019 const BITSubscriber mSubscriber;
LocEngReleaseBITLocEngReleaseBIT1020 inline LocEngReleaseBIT(const AgpsStateMachine* stateMachine,
1021 unsigned int ipv4, char* ipv6) :
1022 LocMsg(),
1023 mSubscriber(stateMachine, ipv4, ipv6)
1024 {
1025 locallog();
1026 }
procLocEngReleaseBIT1027 inline virtual void proc() const
1028 {
1029 AgpsStateMachine* sm = (AgpsStateMachine*)mSubscriber.mStateMachine;
1030 sm->unsubscribeRsrc((Subscriber*)&mSubscriber);
1031 }
locallogLocEngReleaseBIT1032 inline void locallog() const {
1033 LOC_LOGV("LocEngReleaseBIT - ipv4: %d.%d.%d.%d, ipv6: %s",
1034 (unsigned char)(mSubscriber.ID>>24),
1035 (unsigned char)(mSubscriber.ID>>16),
1036 (unsigned char)(mSubscriber.ID>>8),
1037 (unsigned char)mSubscriber.ID,
1038 NULL != mSubscriber.mIPv6Addr ? mSubscriber.mIPv6Addr : "");
1039 }
logLocEngReleaseBIT1040 virtual void log() const {
1041 locallog();
1042 }
1043 };
1044
1045 // LocEngSuplEsOpened
LocEngSuplEsOpened(void * locEng)1046 LocEngSuplEsOpened::LocEngSuplEsOpened(void* locEng) :
1047 LocMsg(), mLocEng(locEng) {
1048 locallog();
1049 }
proc() const1050 void LocEngSuplEsOpened::proc() const {
1051 loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
1052 if (locEng->ds_nif) {
1053 AgpsStateMachine* sm = locEng->ds_nif;
1054 sm->onRsrcEvent(RSRC_GRANTED);
1055 }
1056 }
locallog() const1057 void LocEngSuplEsOpened::locallog() const {
1058 LOC_LOGV("LocEngSuplEsOpened");
1059 }
log() const1060 void LocEngSuplEsOpened::log() const {
1061 locallog();
1062 }
1063
1064 // LocEngSuplEsClosed
LocEngSuplEsClosed(void * locEng)1065 LocEngSuplEsClosed::LocEngSuplEsClosed(void* locEng) :
1066 LocMsg(), mLocEng(locEng) {
1067 locallog();
1068 }
proc() const1069 void LocEngSuplEsClosed::proc() const {
1070 loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
1071 if (locEng->ds_nif) {
1072 AgpsStateMachine* sm = locEng->ds_nif;
1073 sm->onRsrcEvent(RSRC_RELEASED);
1074 }
1075 }
locallog() const1076 void LocEngSuplEsClosed::locallog() const {
1077 LOC_LOGV("LocEngSuplEsClosed");
1078 }
log() const1079 void LocEngSuplEsClosed::log() const {
1080 locallog();
1081 }
1082
1083
1084 // case LOC_ENG_MSG_REQUEST_SUPL_ES:
LocEngRequestSuplEs(void * locEng,int id)1085 LocEngRequestSuplEs::LocEngRequestSuplEs(void* locEng, int id) :
1086 LocMsg(), mLocEng(locEng), mID(id) {
1087 locallog();
1088 }
proc() const1089 void LocEngRequestSuplEs::proc() const {
1090 loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
1091 if (locEng->ds_nif) {
1092 AgpsStateMachine* sm = locEng->ds_nif;
1093 DSSubscriber s(sm, mID);
1094 sm->subscribeRsrc((Subscriber*)&s);
1095 }
1096 else if (locEng->agnss_nif) {
1097 AgpsStateMachine *sm = locEng->agnss_nif;
1098 ATLSubscriber s(mID,
1099 sm,
1100 locEng->adapter,
1101 false);
1102 sm->subscribeRsrc((Subscriber*)&s);
1103 LOC_LOGD("%s:%d]: Using regular ATL for SUPL ES", __func__, __LINE__);
1104 }
1105 else {
1106 locEng->adapter->atlOpenStatus(mID, 0, NULL, -1, -1);
1107 }
1108 }
locallog() const1109 inline void LocEngRequestSuplEs::locallog() const {
1110 LOC_LOGV("LocEngRequestSuplEs");
1111 }
log() const1112 inline void LocEngRequestSuplEs::log() const {
1113 locallog();
1114 }
1115
1116 // case LOC_ENG_MSG_REQUEST_ATL:
LocEngRequestATL(void * locEng,int id,AGpsExtType agps_type)1117 LocEngRequestATL::LocEngRequestATL(void* locEng, int id,
1118 AGpsExtType agps_type) :
1119 LocMsg(), mLocEng(locEng), mID(id), mType(agps_type) {
1120 locallog();
1121 }
proc() const1122 void LocEngRequestATL::proc() const {
1123 loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
1124 AgpsStateMachine* sm = (AgpsStateMachine*)
1125 getAgpsStateMachine(*locEng, mType);
1126 if (sm) {
1127 ATLSubscriber s(mID,
1128 sm,
1129 locEng->adapter,
1130 AGPS_TYPE_INVALID == mType);
1131 sm->subscribeRsrc((Subscriber*)&s);
1132 } else {
1133 locEng->adapter->atlOpenStatus(mID, 0, NULL, -1, mType);
1134 }
1135 }
locallog() const1136 inline void LocEngRequestATL::locallog() const {
1137 LOC_LOGV("LocEngRequestATL");
1138 }
log() const1139 inline void LocEngRequestATL::log() const {
1140 locallog();
1141 }
1142
1143 // case LOC_ENG_MSG_RELEASE_ATL:
LocEngReleaseATL(void * locEng,int id)1144 LocEngReleaseATL::LocEngReleaseATL(void* locEng, int id) :
1145 LocMsg(), mLocEng(locEng), mID(id) {
1146 locallog();
1147 }
proc() const1148 void LocEngReleaseATL::proc() const {
1149 loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
1150
1151 if (locEng->agnss_nif) {
1152 ATLSubscriber s1(mID, locEng->agnss_nif, locEng->adapter, false);
1153 if (locEng->agnss_nif->unsubscribeRsrc((Subscriber*)&s1)) {
1154 LOC_LOGD("%s:%d]: Unsubscribed from agnss_nif",
1155 __func__, __LINE__);
1156 return;
1157 }
1158 }
1159
1160 if (locEng->internet_nif) {
1161 ATLSubscriber s2(mID, locEng->internet_nif, locEng->adapter, false);
1162 if (locEng->internet_nif->unsubscribeRsrc((Subscriber*)&s2)) {
1163 LOC_LOGD("%s:%d]: Unsubscribed from internet_nif",
1164 __func__, __LINE__);
1165 return;
1166 }
1167 }
1168
1169 if (locEng->ds_nif) {
1170 DSSubscriber s3(locEng->ds_nif, mID);
1171 if (locEng->ds_nif->unsubscribeRsrc((Subscriber*)&s3)) {
1172 LOC_LOGD("%s:%d]: Unsubscribed from ds_nif",
1173 __func__, __LINE__);
1174 return;
1175 }
1176 }
1177
1178 LOC_LOGW("%s:%d]: Could not release ATL. "
1179 "No subscribers found\n",
1180 __func__, __LINE__);
1181 locEng->adapter->atlCloseStatus(mID, 0);
1182 }
locallog() const1183 inline void LocEngReleaseATL::locallog() const {
1184 LOC_LOGV("LocEngReleaseATL");
1185 }
log() const1186 inline void LocEngReleaseATL::log() const {
1187 locallog();
1188 }
1189
1190 // case LOC_ENG_MSG_REQUEST_WIFI:
1191 // 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)1192 LocEngReqRelWifi::LocEngReqRelWifi(void* locEng, AGpsExtType type,
1193 loc_if_req_sender_id_e_type sender_id,
1194 char* s, char* p, bool isReq) :
1195 LocMsg(), mLocEng(locEng), mType(type), mSenderId(sender_id),
1196 mSSID(NULL == s ? NULL : new char[SSID_BUF_SIZE]),
1197 mPassword(NULL == p ? NULL : new char[SSID_BUF_SIZE]),
1198 mIsReq(isReq) {
1199 if (NULL != s)
1200 strlcpy(mSSID, s, SSID_BUF_SIZE);
1201 if (NULL != p)
1202 strlcpy(mPassword, p, SSID_BUF_SIZE);
1203 locallog();
1204 }
~LocEngReqRelWifi()1205 LocEngReqRelWifi::~LocEngReqRelWifi() {
1206 if (NULL != mSSID) {
1207 delete[] mSSID;
1208 }
1209 if (NULL != mPassword) {
1210 delete[] mPassword;
1211 }
1212 }
proc() const1213 void LocEngReqRelWifi::proc() const {
1214 loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
1215 if (locEng->wifi_nif) {
1216 WIFISubscriber s(locEng->wifi_nif, mSSID, mPassword, mSenderId);
1217 if (mIsReq) {
1218 locEng->wifi_nif->subscribeRsrc((Subscriber*)&s);
1219 } else {
1220 locEng->wifi_nif->unsubscribeRsrc((Subscriber*)&s);
1221 }
1222 } else {
1223 locEng->adapter->atlOpenStatus(mSenderId, 0, NULL, -1, mType);
1224 }
1225 }
locallog() const1226 inline void LocEngReqRelWifi::locallog() const {
1227 LOC_LOGV("%s - senderId: %d, ssid: %s, password: %s",
1228 mIsReq ? "LocEngRequestWifi" : "LocEngReleaseWifi",
1229 mSenderId,
1230 NULL != mSSID ? mSSID : "",
1231 NULL != mPassword ? mPassword : "");
1232 }
log() const1233 inline void LocEngReqRelWifi::log() const {
1234 locallog();
1235 }
send() const1236 void LocEngReqRelWifi::send() const {
1237 loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
1238 locEng->adapter->sendMsg(this);
1239 }
1240
1241 // case LOC_ENG_MSG_REQUEST_XTRA_DATA:
LocEngRequestXtra(void * locEng)1242 LocEngRequestXtra::LocEngRequestXtra(void* locEng) :
1243 mLocEng(locEng) {
1244 locallog();
1245 }
proc() const1246 void LocEngRequestXtra::proc() const
1247 {
1248 loc_eng_xtra_data_s_type* locEngXtra =
1249 &(((loc_eng_data_s_type*)mLocEng)->xtra_module_data);
1250
1251 if (locEngXtra->download_request_cb != NULL) {
1252 CALLBACK_LOG_CALLFLOW("download_request_cb", %p, mLocEng);
1253 locEngXtra->download_request_cb();
1254 } else {
1255 LOC_LOGE("Callback function for request xtra is NULL");
1256 }
1257 }
locallog() const1258 inline void LocEngRequestXtra::locallog() const {
1259 LOC_LOGV("LocEngReqXtra");
1260 }
log() const1261 inline void LocEngRequestXtra::log() const {
1262 locallog();
1263 }
1264
1265 // case LOC_ENG_MSG_REQUEST_TIME:
LocEngRequestTime(void * locEng)1266 LocEngRequestTime::LocEngRequestTime(void* locEng) :
1267 LocMsg(), mLocEng(locEng)
1268 {
1269 locallog();
1270 }
proc() const1271 void LocEngRequestTime::proc() const {
1272 loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
1273 if (gps_conf.CAPABILITIES & GPS_CAPABILITY_ON_DEMAND_TIME) {
1274 if (locEng->request_utc_time_cb != NULL) {
1275 locEng->request_utc_time_cb();
1276 } else {
1277 LOC_LOGE("Callback function for request time is NULL");
1278 }
1279 }
1280 }
locallog() const1281 inline void LocEngRequestTime::locallog() const {
1282 LOC_LOGV("LocEngReqTime");
1283 }
log() const1284 inline void LocEngRequestTime::log() const {
1285 locallog();
1286 }
1287
1288 // case LOC_ENG_MSG_DELETE_AIDING_DATA:
1289 struct LocEngDelAidData : public LocMsg {
1290 loc_eng_data_s_type* mLocEng;
1291 const GpsAidingData mType;
LocEngDelAidDataLocEngDelAidData1292 inline LocEngDelAidData(loc_eng_data_s_type* locEng,
1293 GpsAidingData f) :
1294 LocMsg(), mLocEng(locEng), mType(f)
1295 {
1296 locallog();
1297 }
procLocEngDelAidData1298 inline virtual void proc() const {
1299 mLocEng->aiding_data_for_deletion = mType;
1300 update_aiding_data_for_deletion(*mLocEng);
1301 }
locallogLocEngDelAidData1302 inline void locallog() const {
1303 LOC_LOGV("aiding data msak %d", mType);
1304 }
logLocEngDelAidData1305 virtual void log() const {
1306 locallog();
1307 }
1308 };
1309
1310 // case LOC_ENG_MSG_ENABLE_DATA:
1311 struct LocEngEnableData : public LocMsg {
1312 LocEngAdapter* mAdapter;
1313 const int mEnable;
1314 char* mAPN;
1315 const int mLen;
LocEngEnableDataLocEngEnableData1316 inline LocEngEnableData(LocEngAdapter* adapter,
1317 const char* name, int len, int enable) :
1318 LocMsg(), mAdapter(adapter),
1319 mEnable(enable), mAPN(NULL), mLen(len)
1320 {
1321 if (NULL != name) {
1322 mAPN = new char[len+1];
1323 memcpy((void*)mAPN, (void*)name, len);
1324 mAPN[len] = 0;
1325 }
1326 locallog();
1327 }
~LocEngEnableDataLocEngEnableData1328 inline ~LocEngEnableData() {
1329 if (NULL != mAPN) {
1330 delete[] mAPN;
1331 }
1332 }
procLocEngEnableData1333 inline virtual void proc() const {
1334 mAdapter->enableData(mEnable);
1335 if (NULL != mAPN) {
1336 mAdapter->setAPN(mAPN, mLen);
1337 }
1338 }
locallogLocEngEnableData1339 inline void locallog() const {
1340 LOC_LOGV("apn: %s\n enable: %d",
1341 (NULL == mAPN) ? "NULL" : mAPN, mEnable);
1342 }
logLocEngEnableData1343 inline virtual void log() const {
1344 locallog();
1345 }
1346 };
1347
1348 // case LOC_ENG_MSG_INJECT_XTRA_DATA:
1349 // loc_eng_xtra.cpp
1350
1351 // case LOC_ENG_MSG_SET_CAPABILITIES:
1352 struct LocEngSetCapabilities : public LocMsg {
1353 loc_eng_data_s_type* mLocEng;
LocEngSetCapabilitiesLocEngSetCapabilities1354 inline LocEngSetCapabilities(loc_eng_data_s_type* locEng) :
1355 LocMsg(), mLocEng(locEng)
1356 {
1357 locallog();
1358 }
procLocEngSetCapabilities1359 inline virtual void proc() const {
1360 if (NULL != mLocEng->set_capabilities_cb) {
1361 LOC_LOGV("calling set_capabilities_cb 0x%x",
1362 gps_conf.CAPABILITIES);
1363 mLocEng->set_capabilities_cb(gps_conf.CAPABILITIES);
1364 } else {
1365 LOC_LOGV("set_capabilities_cb is NULL.\n");
1366 }
1367 }
locallogLocEngSetCapabilities1368 inline void locallog() const
1369 {
1370 LOC_LOGV("LocEngSetCapabilities");
1371 }
logLocEngSetCapabilities1372 inline virtual void log() const
1373 {
1374 locallog();
1375 }
1376 };
1377
1378 // case LOC_ENG_MSG_LOC_INIT:
1379 struct LocEngInit : public LocMsg {
1380 loc_eng_data_s_type* mLocEng;
LocEngInitLocEngInit1381 inline LocEngInit(loc_eng_data_s_type* locEng) :
1382 LocMsg(), mLocEng(locEng)
1383 {
1384 locallog();
1385 }
procLocEngInit1386 inline virtual void proc() const {
1387 loc_eng_reinit(*mLocEng);
1388 // set the capabilities
1389 mLocEng->adapter->sendMsg(new LocEngSetCapabilities(mLocEng));
1390 }
locallogLocEngInit1391 inline void locallog() const
1392 {
1393 LOC_LOGV("LocEngInit");
1394 }
logLocEngInit1395 inline virtual void log() const
1396 {
1397 locallog();
1398 }
1399 };
1400
1401 // case LOC_ENG_MSG_REQUEST_XTRA_SERVER:
1402 // loc_eng_xtra.cpp
1403
1404 // case LOC_ENG_MSG_ATL_OPEN_SUCCESS:
1405 struct LocEngAtlOpenSuccess : public LocMsg {
1406 AgpsStateMachine* mStateMachine;
1407 const int mLen;
1408 char* mAPN;
1409 const AGpsBearerType mBearerType;
LocEngAtlOpenSuccessLocEngAtlOpenSuccess1410 inline LocEngAtlOpenSuccess(AgpsStateMachine* statemachine,
1411 const char* name,
1412 int len,
1413 AGpsBearerType btype) :
1414 LocMsg(),
1415 mStateMachine(statemachine), mLen(len),
1416 mAPN(new char[len+1]), mBearerType(btype)
1417 {
1418 memcpy((void*)mAPN, (void*)name, len);
1419 mAPN[len] = 0;
1420 locallog();
1421 }
~LocEngAtlOpenSuccessLocEngAtlOpenSuccess1422 inline ~LocEngAtlOpenSuccess()
1423 {
1424 delete[] mAPN;
1425 }
procLocEngAtlOpenSuccess1426 inline virtual void proc() const {
1427 mStateMachine->setBearer(mBearerType);
1428 mStateMachine->setAPN(mAPN, mLen);
1429 mStateMachine->onRsrcEvent(RSRC_GRANTED);
1430 }
locallogLocEngAtlOpenSuccess1431 inline void locallog() const {
1432 LOC_LOGV("LocEngAtlOpenSuccess agps type: %s\n apn: %s\n"
1433 " bearer type: %s",
1434 loc_get_agps_type_name(mStateMachine->getType()),
1435 mAPN,
1436 loc_get_agps_bear_name(mBearerType));
1437 }
logLocEngAtlOpenSuccess1438 inline virtual void log() const {
1439 locallog();
1440 }
1441 };
1442
1443 // case LOC_ENG_MSG_ATL_CLOSED:
1444 struct LocEngAtlClosed : public LocMsg {
1445 AgpsStateMachine* mStateMachine;
LocEngAtlClosedLocEngAtlClosed1446 inline LocEngAtlClosed(AgpsStateMachine* statemachine) :
1447 LocMsg(), mStateMachine(statemachine) {
1448 locallog();
1449 }
procLocEngAtlClosed1450 inline virtual void proc() const {
1451 mStateMachine->onRsrcEvent(RSRC_RELEASED);
1452 }
locallogLocEngAtlClosed1453 inline void locallog() const {
1454 LOC_LOGV("LocEngAtlClosed");
1455 }
logLocEngAtlClosed1456 inline virtual void log() const {
1457 locallog();
1458 }
1459 };
1460
1461 // case LOC_ENG_MSG_ATL_OPEN_FAILED:
1462 struct LocEngAtlOpenFailed : public LocMsg {
1463 AgpsStateMachine* mStateMachine;
LocEngAtlOpenFailedLocEngAtlOpenFailed1464 inline LocEngAtlOpenFailed(AgpsStateMachine* statemachine) :
1465 LocMsg(), mStateMachine(statemachine) {
1466 locallog();
1467 }
procLocEngAtlOpenFailed1468 inline virtual void proc() const {
1469 mStateMachine->onRsrcEvent(RSRC_DENIED);
1470 }
locallogLocEngAtlOpenFailed1471 inline void locallog() const {
1472 LOC_LOGV("LocEngAtlOpenFailed");
1473 }
logLocEngAtlOpenFailed1474 inline virtual void log() const {
1475 locallog();
1476 }
1477 };
1478
1479 // case LOC_ENG_MSG_ENGINE_DOWN:
LocEngDown(void * locEng)1480 LocEngDown::LocEngDown(void* locEng) :
1481 LocMsg(), mLocEng(locEng) {
1482 locallog();
1483 }
proc() const1484 inline void LocEngDown::proc() const {
1485 loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
1486 loc_eng_handle_engine_down(*locEng);
1487 }
locallog() const1488 inline void LocEngDown::locallog() const {
1489 LOC_LOGV("LocEngDown");
1490 }
log() const1491 inline void LocEngDown::log() const {
1492 locallog();
1493 }
1494
1495 // case LOC_ENG_MSG_ENGINE_UP:
LocEngUp(void * locEng)1496 LocEngUp::LocEngUp(void* locEng) :
1497 LocMsg(), mLocEng(locEng) {
1498 locallog();
1499 }
proc() const1500 inline void LocEngUp::proc() const {
1501 loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
1502 loc_eng_handle_engine_up(*locEng);
1503 }
locallog() const1504 inline void LocEngUp::locallog() const {
1505 LOC_LOGV("LocEngUp");
1506 }
log() const1507 inline void LocEngUp::log() const {
1508 locallog();
1509 }
1510
1511 struct LocEngDataClientInit : public LocMsg {
1512 loc_eng_data_s_type* mLocEng;
LocEngDataClientInitLocEngDataClientInit1513 inline LocEngDataClientInit(loc_eng_data_s_type* locEng) :
1514 LocMsg(), mLocEng(locEng) {
1515 locallog();
1516 }
procLocEngDataClientInit1517 virtual void proc() const {
1518 loc_eng_data_s_type *locEng = (loc_eng_data_s_type *)mLocEng;
1519 if(!locEng->adapter->initDataServiceClient()) {
1520 locEng->ds_nif = new DSStateMachine(servicerTypeExt,
1521 (void *)dataCallCb,
1522 locEng->adapter);
1523 }
1524 }
locallogLocEngDataClientInit1525 void locallog() const {
1526 LOC_LOGV("LocEngDataClientInit\n");
1527 }
logLocEngDataClientInit1528 virtual void log() const {
1529 locallog();
1530 }
1531 };
1532
1533 struct LocEngInstallAGpsCert : public LocMsg {
1534 LocEngAdapter* mpAdapter;
1535 const size_t mNumberOfCerts;
1536 const uint32_t mSlotBitMask;
1537 DerEncodedCertificate* mpData;
LocEngInstallAGpsCertLocEngInstallAGpsCert1538 inline LocEngInstallAGpsCert(LocEngAdapter* adapter,
1539 const DerEncodedCertificate* pData,
1540 size_t numberOfCerts,
1541 uint32_t slotBitMask) :
1542 LocMsg(), mpAdapter(adapter),
1543 mNumberOfCerts(numberOfCerts), mSlotBitMask(slotBitMask),
1544 mpData(new DerEncodedCertificate[mNumberOfCerts])
1545 {
1546 for (int i=0; i < mNumberOfCerts; i++) {
1547 mpData[i].data = new u_char[pData[i].length];
1548 if (mpData[i].data) {
1549 memcpy(mpData[i].data, (void*)pData[i].data, pData[i].length);
1550 mpData[i].length = pData[i].length;
1551 } else {
1552 LOC_LOGE("malloc failed for cert#%d", i);
1553 break;
1554 }
1555 }
1556 locallog();
1557 }
~LocEngInstallAGpsCertLocEngInstallAGpsCert1558 inline ~LocEngInstallAGpsCert()
1559 {
1560 for (int i=0; i < mNumberOfCerts; i++) {
1561 if (mpData[i].data) {
1562 delete[] mpData[i].data;
1563 }
1564 }
1565 delete[] mpData;
1566 }
procLocEngInstallAGpsCert1567 inline virtual void proc() const {
1568 mpAdapter->installAGpsCert(mpData, mNumberOfCerts, mSlotBitMask);
1569 }
locallogLocEngInstallAGpsCert1570 inline void locallog() const {
1571 LOC_LOGV("LocEngInstallAGpsCert - certs=%u mask=%u",
1572 mNumberOfCerts, mSlotBitMask);
1573 }
logLocEngInstallAGpsCert1574 inline virtual void log() const {
1575 locallog();
1576 }
1577 };
1578
1579 struct LocEngUpdateRegistrationMask : public LocMsg {
1580 loc_eng_data_s_type* mLocEng;
1581 LOC_API_ADAPTER_EVENT_MASK_T mMask;
1582 loc_registration_mask_status mIsEnabled;
LocEngUpdateRegistrationMaskLocEngUpdateRegistrationMask1583 inline LocEngUpdateRegistrationMask(loc_eng_data_s_type* locEng,
1584 LOC_API_ADAPTER_EVENT_MASK_T mask,
1585 loc_registration_mask_status isEnabled) :
1586 LocMsg(), mLocEng(locEng), mMask(mask), mIsEnabled(isEnabled) {
1587 locallog();
1588 }
procLocEngUpdateRegistrationMask1589 inline virtual void proc() const {
1590 loc_eng_data_s_type *locEng = (loc_eng_data_s_type *)mLocEng;
1591 locEng->adapter->updateRegistrationMask(mMask,
1592 mIsEnabled);
1593 }
locallogLocEngUpdateRegistrationMask1594 void locallog() const {
1595 LOC_LOGV("LocEngUpdateRegistrationMask\n");
1596 }
logLocEngUpdateRegistrationMask1597 virtual void log() const {
1598 locallog();
1599 }
1600 };
1601
1602 struct LocEngGnssConstellationConfig : public LocMsg {
1603 LocEngAdapter* mAdapter;
LocEngGnssConstellationConfigLocEngGnssConstellationConfig1604 inline LocEngGnssConstellationConfig(LocEngAdapter* adapter) :
1605 LocMsg(), mAdapter(adapter) {
1606 locallog();
1607 }
procLocEngGnssConstellationConfig1608 inline virtual void proc() const {
1609 if (mAdapter->gnssConstellationConfig()) {
1610 LOC_LOGV("Modem supports GNSS measurements\n");
1611 gps_conf.CAPABILITIES |= GPS_CAPABILITY_MEASUREMENTS;
1612 } else {
1613 LOC_LOGV("Modem does not support GNSS measurements\n");
1614 }
1615 }
locallogLocEngGnssConstellationConfig1616 void locallog() const {
1617 LOC_LOGV("LocEngGnssConstellationConfig\n");
1618 }
logLocEngGnssConstellationConfig1619 virtual void log() const {
1620 locallog();
1621 }
1622 };
1623
1624 // case LOC_ENG_MSG_REPORT_GNSS_MEASUREMENT:
LocEngReportGpsMeasurement(void * locEng,GpsData & gpsData)1625 LocEngReportGpsMeasurement::LocEngReportGpsMeasurement(void* locEng,
1626 GpsData &gpsData) :
1627 LocMsg(), mLocEng(locEng), mGpsData(gpsData)
1628 {
1629 locallog();
1630 }
proc() const1631 void LocEngReportGpsMeasurement::proc() const {
1632 loc_eng_data_s_type* locEng = (loc_eng_data_s_type*) mLocEng;
1633 if (locEng->mute_session_state != LOC_MUTE_SESS_IN_SESSION)
1634 {
1635 if (locEng->gps_measurement_cb != NULL) {
1636 locEng->gps_measurement_cb((GpsData*)&(mGpsData));
1637 }
1638 }
1639 }
locallog() const1640 void LocEngReportGpsMeasurement::locallog() const {
1641 IF_LOC_LOGV {
1642 LOC_LOGV("%s:%d]: Received in GPS HAL."
1643 "GNSS Measurements count: %d \n",
1644 __func__, __LINE__, mGpsData.measurement_count);
1645 for (int i =0; i< mGpsData.measurement_count && i < GPS_MAX_SVS; i++) {
1646 LOC_LOGV(" GNSS measurement data in GPS HAL: \n"
1647 " GPS_HAL => Measurement ID | prn | time_offset_ns | state |"
1648 " received_gps_tow_ns| c_n0_dbhz | pseudorange_rate_mps |"
1649 " pseudorange_rate_uncertainty_mps |"
1650 " accumulated_delta_range_state | flags \n"
1651 " GPS_HAL => %d | %d | %f | %d | %lld | %f | %f | %f | %d | %d \n",
1652 i,
1653 mGpsData.measurements[i].prn,
1654 mGpsData.measurements[i].time_offset_ns,
1655 mGpsData.measurements[i].state,
1656 mGpsData.measurements[i].received_gps_tow_ns,
1657 mGpsData.measurements[i].c_n0_dbhz,
1658 mGpsData.measurements[i].pseudorange_rate_mps,
1659 mGpsData.measurements[i].pseudorange_rate_uncertainty_mps,
1660 mGpsData.measurements[i].accumulated_delta_range_state,
1661 mGpsData.measurements[i].flags);
1662 }
1663 LOC_LOGV(" GPS_HAL => Clocks Info: type | time_ns \n"
1664 " GPS_HAL => Clocks Info: %d | %lld", mGpsData.clock.type,
1665 mGpsData.clock.time_ns);
1666 }
1667 }
log() const1668 inline void LocEngReportGpsMeasurement::log() const {
1669 locallog();
1670 }
1671
1672 /*********************************************************************
1673 * Initialization checking macros
1674 *********************************************************************/
1675 #define STATE_CHECK(ctx, x, ret) \
1676 if (!(ctx)) \
1677 { \
1678 /* Not intialized, abort */\
1679 LOC_LOGE("%s: log_eng state error: %s", __func__, x); \
1680 EXIT_LOG(%s, x); \
1681 ret; \
1682 }
1683 #define INIT_CHECK(ctx, ret) STATE_CHECK(ctx, "instance not initialized", ret)
1684
getCarrierCapabilities()1685 uint32_t getCarrierCapabilities() {
1686 #define carrierMSA (uint32_t)0x2
1687 #define carrierMSB (uint32_t)0x1
1688 #define gpsConfMSA (uint32_t)0x4
1689 #define gpsConfMSB (uint32_t)0x2
1690 uint32_t capabilities = gps_conf.CAPABILITIES;
1691 if ((gps_conf.SUPL_MODE & carrierMSA) != carrierMSA) {
1692 capabilities &= ~gpsConfMSA;
1693 }
1694 if ((gps_conf.SUPL_MODE & carrierMSB) != carrierMSB) {
1695 capabilities &= ~gpsConfMSB;
1696 }
1697
1698 LOC_LOGV("getCarrierCapabilities: CAPABILITIES %x, SUPL_MODE %x, carrier capabilities %x",
1699 gps_conf.CAPABILITIES, gps_conf.SUPL_MODE, capabilities);
1700 return capabilities;
1701 }
1702
1703 /*===========================================================================
1704 FUNCTION loc_eng_init
1705
1706 DESCRIPTION
1707 Initialize the location engine, this include setting up global datas
1708 and registers location engien with loc api service.
1709
1710 DEPENDENCIES
1711 None
1712
1713 RETURN VALUE
1714 0: success
1715
1716 SIDE EFFECTS
1717 N/A
1718
1719 ===========================================================================*/
loc_eng_init(loc_eng_data_s_type & loc_eng_data,LocCallbacks * callbacks,LOC_API_ADAPTER_EVENT_MASK_T event,ContextBase * context)1720 int loc_eng_init(loc_eng_data_s_type &loc_eng_data, LocCallbacks* callbacks,
1721 LOC_API_ADAPTER_EVENT_MASK_T event, ContextBase* context)
1722
1723 {
1724 int ret_val = 0;
1725
1726 ENTRY_LOG_CALLFLOW();
1727 if (NULL == callbacks || 0 == event) {
1728 LOC_LOGE("loc_eng_init: bad parameters cb %p eMask %d", callbacks, event);
1729 ret_val = -1;
1730 EXIT_LOG(%d, ret_val);
1731 return ret_val;
1732 }
1733
1734 STATE_CHECK((NULL == loc_eng_data.adapter),
1735 "instance already initialized", return 0);
1736
1737 memset(&loc_eng_data, 0, sizeof (loc_eng_data));
1738
1739 // Save callbacks
1740 loc_eng_data.location_cb = callbacks->location_cb;
1741 loc_eng_data.sv_status_cb = callbacks->sv_status_cb;
1742 loc_eng_data.status_cb = callbacks->status_cb;
1743 loc_eng_data.nmea_cb = callbacks->nmea_cb;
1744 loc_eng_data.set_capabilities_cb = callbacks->set_capabilities_cb;
1745 loc_eng_data.acquire_wakelock_cb = callbacks->acquire_wakelock_cb;
1746 loc_eng_data.release_wakelock_cb = callbacks->release_wakelock_cb;
1747 loc_eng_data.request_utc_time_cb = callbacks->request_utc_time_cb;
1748 loc_eng_data.location_ext_parser = callbacks->location_ext_parser ?
1749 callbacks->location_ext_parser : noProc;
1750 loc_eng_data.sv_ext_parser = callbacks->sv_ext_parser ?
1751 callbacks->sv_ext_parser : noProc;
1752 loc_eng_data.intermediateFix = gps_conf.INTERMEDIATE_POS;
1753 // initial states taken care of by the memset above
1754 // loc_eng_data.engine_status -- GPS_STATUS_NONE;
1755 // loc_eng_data.fix_session_status -- GPS_STATUS_NONE;
1756 // loc_eng_data.mute_session_state -- LOC_MUTE_SESS_NONE;
1757
1758 if ((event & LOC_API_ADAPTER_BIT_NMEA_1HZ_REPORT) && (gps_conf.NMEA_PROVIDER == NMEA_PROVIDER_AP))
1759 {
1760 event = event ^ LOC_API_ADAPTER_BIT_NMEA_1HZ_REPORT; // unregister for modem NMEA report
1761 loc_eng_data.generateNmea = true;
1762 }
1763 else
1764 {
1765 loc_eng_data.generateNmea = false;
1766 }
1767
1768 loc_eng_data.adapter =
1769 new LocEngAdapter(event, &loc_eng_data, context,
1770 (MsgTask::tCreate)callbacks->create_thread_cb);
1771
1772 LOC_LOGD("loc_eng_init created client, id = %p\n",
1773 loc_eng_data.adapter);
1774 loc_eng_data.adapter->sendMsg(new LocEngInit(&loc_eng_data));
1775
1776 EXIT_LOG(%d, ret_val);
1777 return ret_val;
1778 }
1779
loc_eng_reinit(loc_eng_data_s_type & loc_eng_data)1780 static int loc_eng_reinit(loc_eng_data_s_type &loc_eng_data)
1781 {
1782 ENTRY_LOG();
1783 int ret_val = LOC_API_ADAPTER_ERR_SUCCESS;
1784 LocEngAdapter* adapter = loc_eng_data.adapter;
1785
1786 adapter->sendMsg(new LocEngGnssConstellationConfig(adapter));
1787 adapter->sendMsg(new LocEngSuplVer(adapter, gps_conf.SUPL_VER));
1788 adapter->sendMsg(new LocEngLppConfig(adapter, gps_conf.LPP_PROFILE));
1789 adapter->sendMsg(new LocEngSensorControlConfig(adapter, sap_conf.SENSOR_USAGE,
1790 sap_conf.SENSOR_PROVIDER));
1791 adapter->sendMsg(new LocEngAGlonassProtocol(adapter, gps_conf.A_GLONASS_POS_PROTOCOL_SELECT));
1792
1793 /* Make sure at least one of the sensor property is specified by the user in the gps.conf file. */
1794 if( sap_conf.GYRO_BIAS_RANDOM_WALK_VALID ||
1795 sap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY_VALID ||
1796 sap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY_VALID ||
1797 sap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY_VALID ||
1798 sap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY_VALID ) {
1799 adapter->sendMsg(new LocEngSensorProperties(adapter,
1800 sap_conf.GYRO_BIAS_RANDOM_WALK_VALID,
1801 sap_conf.GYRO_BIAS_RANDOM_WALK,
1802 sap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY_VALID,
1803 sap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY,
1804 sap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY_VALID,
1805 sap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY,
1806 sap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY_VALID,
1807 sap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY,
1808 sap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY_VALID,
1809 sap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY));
1810 }
1811
1812 adapter->sendMsg(new LocEngSensorPerfControlConfig(adapter,
1813 sap_conf.SENSOR_CONTROL_MODE,
1814 sap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH,
1815 sap_conf.SENSOR_ACCEL_BATCHES_PER_SEC,
1816 sap_conf.SENSOR_GYRO_SAMPLES_PER_BATCH,
1817 sap_conf.SENSOR_GYRO_BATCHES_PER_SEC,
1818 sap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH_HIGH,
1819 sap_conf.SENSOR_ACCEL_BATCHES_PER_SEC_HIGH,
1820 sap_conf.SENSOR_GYRO_SAMPLES_PER_BATCH_HIGH,
1821 sap_conf.SENSOR_GYRO_BATCHES_PER_SEC_HIGH,
1822 sap_conf.SENSOR_ALGORITHM_CONFIG_MASK));
1823
1824 adapter->sendMsg(new LocEngEnableData(adapter, NULL, 0, (agpsStatus ? 1:0)));
1825
1826 loc_eng_xtra_version_check(loc_eng_data, gps_conf.XTRA_VERSION_CHECK);
1827
1828 LOC_LOGD("loc_eng_reinit reinit() successful");
1829 EXIT_LOG(%d, ret_val);
1830 return ret_val;
1831 }
1832
1833 /*===========================================================================
1834 FUNCTION loc_eng_cleanup
1835
1836 DESCRIPTION
1837 Cleans location engine. The location client handle will be released.
1838
1839 DEPENDENCIES
1840 None
1841
1842 RETURN VALUE
1843 None
1844
1845 SIDE EFFECTS
1846 N/A
1847
1848 ===========================================================================*/
loc_eng_cleanup(loc_eng_data_s_type & loc_eng_data)1849 void loc_eng_cleanup(loc_eng_data_s_type &loc_eng_data)
1850 {
1851 ENTRY_LOG_CALLFLOW();
1852 INIT_CHECK(loc_eng_data.adapter, return);
1853
1854 // XTRA has no state, so we are fine with it.
1855
1856 // we need to check and clear NI
1857 #if 0
1858 // we need to check and clear ATL
1859 if (NULL != loc_eng_data.agnss_nif) {
1860 delete loc_eng_data.agnss_nif;
1861 loc_eng_data.agnss_nif = NULL;
1862 }
1863 if (NULL != loc_eng_data.internet_nif) {
1864 delete loc_eng_data.internet_nif;
1865 loc_eng_data.internet_nif = NULL;
1866 }
1867 #endif
1868 if (loc_eng_data.adapter->isInSession())
1869 {
1870 LOC_LOGD("loc_eng_cleanup: fix not stopped. stop it now.");
1871 loc_eng_stop(loc_eng_data);
1872 }
1873
1874 #if 0 // can't afford to actually clean up, for many reason.
1875
1876 LOC_LOGD("loc_eng_init: client opened. close it now.");
1877 delete loc_eng_data.adapter;
1878 loc_eng_data.adapter = NULL;
1879
1880 loc_eng_dmn_conn_loc_api_server_unblock();
1881 loc_eng_dmn_conn_loc_api_server_join();
1882
1883 #endif
1884
1885 EXIT_LOG(%s, VOID_RET);
1886 }
1887
1888
1889 /*===========================================================================
1890 FUNCTION loc_eng_start
1891
1892 DESCRIPTION
1893 Starts the tracking session
1894
1895 DEPENDENCIES
1896 None
1897
1898 RETURN VALUE
1899 0: success
1900
1901 SIDE EFFECTS
1902 N/A
1903
1904 ===========================================================================*/
loc_eng_start(loc_eng_data_s_type & loc_eng_data)1905 int loc_eng_start(loc_eng_data_s_type &loc_eng_data)
1906 {
1907 ENTRY_LOG_CALLFLOW();
1908 INIT_CHECK(loc_eng_data.adapter, return -1);
1909
1910 if(! loc_eng_data.adapter->getUlpProxy()->sendStartFix())
1911 {
1912 loc_eng_data.adapter->sendMsg(new LocEngStartFix(loc_eng_data.adapter));
1913 }
1914
1915 EXIT_LOG(%d, 0);
1916 return 0;
1917 }
1918
loc_eng_start_handler(loc_eng_data_s_type & loc_eng_data)1919 static int loc_eng_start_handler(loc_eng_data_s_type &loc_eng_data)
1920 {
1921 ENTRY_LOG();
1922 int ret_val = LOC_API_ADAPTER_ERR_SUCCESS;
1923
1924 if (!loc_eng_data.adapter->isInSession()) {
1925 ret_val = loc_eng_data.adapter->startFix();
1926
1927 if (ret_val == LOC_API_ADAPTER_ERR_SUCCESS ||
1928 ret_val == LOC_API_ADAPTER_ERR_ENGINE_DOWN ||
1929 ret_val == LOC_API_ADAPTER_ERR_PHONE_OFFLINE ||
1930 ret_val == LOC_API_ADAPTER_ERR_INTERNAL)
1931 {
1932 loc_eng_data.adapter->setInSession(TRUE);
1933 }
1934 }
1935
1936 EXIT_LOG(%d, ret_val);
1937 return ret_val;
1938 }
1939
1940 /*===========================================================================
1941 FUNCTION loc_eng_stop_wrapper
1942
1943 DESCRIPTION
1944 Stops the tracking session
1945
1946 DEPENDENCIES
1947 None
1948
1949 RETURN VALUE
1950 0: success
1951
1952 SIDE EFFECTS
1953 N/A
1954
1955 ===========================================================================*/
loc_eng_stop(loc_eng_data_s_type & loc_eng_data)1956 int loc_eng_stop(loc_eng_data_s_type &loc_eng_data)
1957 {
1958 ENTRY_LOG_CALLFLOW();
1959 INIT_CHECK(loc_eng_data.adapter, return -1);
1960
1961 if(! loc_eng_data.adapter->getUlpProxy()->sendStopFix())
1962 {
1963 loc_eng_data.adapter->sendMsg(new LocEngStopFix(loc_eng_data.adapter));
1964 }
1965
1966 EXIT_LOG(%d, 0);
1967 return 0;
1968 }
1969
loc_eng_stop_handler(loc_eng_data_s_type & loc_eng_data)1970 static int loc_eng_stop_handler(loc_eng_data_s_type &loc_eng_data)
1971 {
1972 ENTRY_LOG();
1973 int ret_val = LOC_API_ADAPTER_ERR_SUCCESS;
1974
1975 if (loc_eng_data.adapter->isInSession()) {
1976
1977 ret_val = loc_eng_data.adapter->stopFix();
1978 loc_eng_data.adapter->setInSession(FALSE);
1979 }
1980
1981 EXIT_LOG(%d, ret_val);
1982 return ret_val;
1983 }
1984
1985 /*===========================================================================
1986 FUNCTION loc_eng_mute_one_session
1987
1988 DESCRIPTION
1989 Mutes one session
1990
1991 DEPENDENCIES
1992 None
1993
1994 RETURN VALUE
1995 0: Success
1996
1997 SIDE EFFECTS
1998 N/A
1999
2000 ===========================================================================*/
loc_eng_mute_one_session(loc_eng_data_s_type & loc_eng_data)2001 void loc_eng_mute_one_session(loc_eng_data_s_type &loc_eng_data)
2002 {
2003 ENTRY_LOG();
2004 loc_eng_data.mute_session_state = LOC_MUTE_SESS_WAIT;
2005 EXIT_LOG(%s, VOID_RET);
2006 }
2007
2008 /*===========================================================================
2009 FUNCTION loc_eng_set_position_mode
2010
2011 DESCRIPTION
2012 Sets the mode and fix frequency for the tracking session.
2013
2014 DEPENDENCIES
2015 None
2016
2017 RETURN VALUE
2018 0: success
2019
2020 SIDE EFFECTS
2021 N/A
2022
2023 ===========================================================================*/
loc_eng_set_position_mode(loc_eng_data_s_type & loc_eng_data,LocPosMode & params)2024 int loc_eng_set_position_mode(loc_eng_data_s_type &loc_eng_data,
2025 LocPosMode ¶ms)
2026 {
2027 ENTRY_LOG_CALLFLOW();
2028 INIT_CHECK(loc_eng_data.adapter, return -1);
2029
2030 // The position mode for AUTO/GSS/QCA1530 can only be standalone
2031 if (!(gps_conf.CAPABILITIES & GPS_CAPABILITY_MSB) &&
2032 !(gps_conf.CAPABILITIES & GPS_CAPABILITY_MSA) &&
2033 (params.mode != LOC_POSITION_MODE_STANDALONE)) {
2034 params.mode = LOC_POSITION_MODE_STANDALONE;
2035 LOC_LOGD("Position mode changed to standalone for target with AUTO/GSS/qca1530.");
2036 }
2037
2038 if(! loc_eng_data.adapter->getUlpProxy()->sendFixMode(params))
2039 {
2040 LocEngAdapter* adapter = loc_eng_data.adapter;
2041 adapter->sendMsg(new LocEngPositionMode(adapter, params));
2042 }
2043
2044 EXIT_LOG(%d, 0);
2045 return 0;
2046 }
2047
2048 /*===========================================================================
2049 FUNCTION loc_eng_inject_time
2050
2051 DESCRIPTION
2052 This is used by Java native function to do time injection.
2053
2054 DEPENDENCIES
2055 None
2056
2057 RETURN VALUE
2058 0
2059
2060 SIDE EFFECTS
2061 N/A
2062
2063 ===========================================================================*/
loc_eng_inject_time(loc_eng_data_s_type & loc_eng_data,GpsUtcTime time,int64_t timeReference,int uncertainty)2064 int loc_eng_inject_time(loc_eng_data_s_type &loc_eng_data, GpsUtcTime time,
2065 int64_t timeReference, int uncertainty)
2066 {
2067 ENTRY_LOG_CALLFLOW();
2068 INIT_CHECK(loc_eng_data.adapter, return -1);
2069 LocEngAdapter* adapter = loc_eng_data.adapter;
2070
2071 adapter->sendMsg(new LocEngSetTime(adapter, time, timeReference,
2072 uncertainty));
2073
2074 EXIT_LOG(%d, 0);
2075 return 0;
2076 }
2077
2078
2079 /*===========================================================================
2080 FUNCTION loc_eng_inject_location
2081
2082 DESCRIPTION
2083 This is used by Java native function to do location injection.
2084
2085 DEPENDENCIES
2086 None
2087
2088 RETURN VALUE
2089 0 : Successful
2090 error code : Failure
2091
2092 SIDE EFFECTS
2093 N/A
2094 ===========================================================================*/
loc_eng_inject_location(loc_eng_data_s_type & loc_eng_data,double latitude,double longitude,float accuracy)2095 int loc_eng_inject_location(loc_eng_data_s_type &loc_eng_data, double latitude,
2096 double longitude, float accuracy)
2097 {
2098 ENTRY_LOG_CALLFLOW();
2099 INIT_CHECK(loc_eng_data.adapter, return -1);
2100 LocEngAdapter* adapter = loc_eng_data.adapter;
2101 if(adapter->mSupportsPositionInjection)
2102 {
2103 adapter->sendMsg(new LocEngInjectLocation(adapter, latitude, longitude,
2104 accuracy));
2105 }
2106
2107 EXIT_LOG(%d, 0);
2108 return 0;
2109 }
2110
2111
2112 /*===========================================================================
2113 FUNCTION loc_eng_delete_aiding_data
2114
2115 DESCRIPTION
2116 This is used by Java native function to delete the aiding data. The function
2117 updates the global variable for the aiding data to be deleted. If the GPS
2118 engine is off, the aiding data will be deleted. Otherwise, the actual action
2119 will happen when gps engine is turned off.
2120
2121 DEPENDENCIES
2122 Assumes the aiding data type specified in GpsAidingData matches with
2123 LOC API specification.
2124
2125 RETURN VALUE
2126 None
2127
2128 SIDE EFFECTS
2129 N/A
2130
2131 ===========================================================================*/
loc_eng_delete_aiding_data(loc_eng_data_s_type & loc_eng_data,GpsAidingData f)2132 void loc_eng_delete_aiding_data(loc_eng_data_s_type &loc_eng_data, GpsAidingData f)
2133 {
2134 ENTRY_LOG_CALLFLOW();
2135 INIT_CHECK(loc_eng_data.adapter, return);
2136
2137 loc_eng_data.adapter->sendMsg(new LocEngDelAidData(&loc_eng_data, f));
2138
2139 EXIT_LOG(%s, VOID_RET);
2140 }
2141
2142 /*===========================================================================
2143
2144 FUNCTION loc_inform_gps_state
2145
2146 DESCRIPTION
2147 Informs the GPS Provider about the GPS status
2148
2149 DEPENDENCIES
2150 None
2151
2152 RETURN VALUE
2153 None
2154
2155 SIDE EFFECTS
2156 N/A
2157
2158 ===========================================================================*/
loc_inform_gps_status(loc_eng_data_s_type & loc_eng_data,GpsStatusValue status)2159 static void loc_inform_gps_status(loc_eng_data_s_type &loc_eng_data, GpsStatusValue status)
2160 {
2161 ENTRY_LOG();
2162
2163 if (loc_eng_data.status_cb)
2164 {
2165 GpsStatus gs = { sizeof(gs),status };
2166 CALLBACK_LOG_CALLFLOW("status_cb", %s,
2167 loc_get_gps_status_name(gs.status));
2168 loc_eng_data.status_cb(&gs);
2169 }
2170
2171 EXIT_LOG(%s, VOID_RET);
2172 }
2173
loc_eng_get_zpp_handler(loc_eng_data_s_type & loc_eng_data)2174 static int loc_eng_get_zpp_handler(loc_eng_data_s_type &loc_eng_data)
2175 {
2176 ENTRY_LOG();
2177 int ret_val = LOC_API_ADAPTER_ERR_SUCCESS;
2178 UlpLocation location;
2179 LocPosTechMask tech_mask = LOC_POS_TECH_MASK_DEFAULT;
2180 GpsLocationExtended locationExtended;
2181 memset(&locationExtended, 0, sizeof (GpsLocationExtended));
2182 locationExtended.size = sizeof(locationExtended);
2183
2184 ret_val = loc_eng_data.adapter->getZpp(location.gpsLocation, tech_mask);
2185 //Mark the location source as from ZPP
2186 location.gpsLocation.flags |= LOCATION_HAS_SOURCE_INFO;
2187 location.position_source = ULP_LOCATION_IS_FROM_ZPP;
2188
2189 loc_eng_data.adapter->getUlpProxy()->reportPosition(location,
2190 locationExtended,
2191 NULL,
2192 LOC_SESS_SUCCESS,
2193 tech_mask);
2194
2195 EXIT_LOG(%d, ret_val);
2196 return ret_val;
2197 }
2198
2199 /*
2200 Callback function passed to Data Services State Machine
2201 This becomes part of the state machine's servicer and
2202 is used to send requests to the data services client
2203 */
dataCallCb(void * cb_data)2204 static int dataCallCb(void *cb_data)
2205 {
2206 LOC_LOGD("Enter dataCallCb\n");
2207 int ret=0;
2208 if(cb_data != NULL) {
2209 dsCbData *cbData = (dsCbData *)cb_data;
2210 LocEngAdapter *locAdapter = (LocEngAdapter *)cbData->mAdapter;
2211 if(cbData->action == GPS_REQUEST_AGPS_DATA_CONN) {
2212 LOC_LOGD("dataCallCb GPS_REQUEST_AGPS_DATA_CONN\n");
2213 ret = locAdapter->openAndStartDataCall();
2214 }
2215 else if(cbData->action == GPS_RELEASE_AGPS_DATA_CONN) {
2216 LOC_LOGD("dataCallCb GPS_RELEASE_AGPS_DATA_CONN\n");
2217 locAdapter->stopDataCall();
2218 }
2219 }
2220 else {
2221 LOC_LOGE("NULL argument received. Failing.\n");
2222 ret = -1;
2223 goto err;
2224 }
2225
2226 err:
2227 LOC_LOGD("Exit dataCallCb ret = %d\n", ret);
2228 return ret;
2229 }
2230
2231 /*===========================================================================
2232 FUNCTION loc_eng_agps_reinit
2233
2234 DESCRIPTION
2235 2nd half of loc_eng_agps_init(), singled out for modem restart to use.
2236
2237 DEPENDENCIES
2238 NONE
2239
2240 RETURN VALUE
2241 0
2242
2243 SIDE EFFECTS
2244 N/A
2245
2246 ===========================================================================*/
loc_eng_agps_reinit(loc_eng_data_s_type & loc_eng_data)2247 static void loc_eng_agps_reinit(loc_eng_data_s_type &loc_eng_data)
2248 {
2249 ENTRY_LOG();
2250
2251 // Set server addresses which came before init
2252 if (loc_eng_data.supl_host_set)
2253 {
2254 loc_eng_set_server(loc_eng_data, LOC_AGPS_SUPL_SERVER,
2255 loc_eng_data.supl_host_buf,
2256 loc_eng_data.supl_port_buf);
2257 }
2258
2259 if (loc_eng_data.c2k_host_set)
2260 {
2261 loc_eng_set_server(loc_eng_data, LOC_AGPS_CDMA_PDE_SERVER,
2262 loc_eng_data.c2k_host_buf,
2263 loc_eng_data.c2k_port_buf);
2264 }
2265 EXIT_LOG(%s, VOID_RET);
2266 }
2267 /*===========================================================================
2268 FUNCTION loc_eng_agps_init
2269
2270 DESCRIPTION
2271 Initialize the AGps interface.
2272
2273 DEPENDENCIES
2274 NONE
2275
2276 RETURN VALUE
2277 0
2278
2279 SIDE EFFECTS
2280 N/A
2281
2282 ===========================================================================*/
loc_eng_agps_init(loc_eng_data_s_type & loc_eng_data,AGpsExtCallbacks * callbacks)2283 void loc_eng_agps_init(loc_eng_data_s_type &loc_eng_data, AGpsExtCallbacks* callbacks)
2284 {
2285 ENTRY_LOG_CALLFLOW();
2286 INIT_CHECK(loc_eng_data.adapter, return);
2287 STATE_CHECK((NULL == loc_eng_data.agps_status_cb),
2288 "agps instance already initialized",
2289 return);
2290 if (callbacks == NULL) {
2291 LOC_LOGE("loc_eng_agps_init: bad parameters cb %p", callbacks);
2292 EXIT_LOG(%s, VOID_RET);
2293 return;
2294 }
2295 LocEngAdapter* adapter = loc_eng_data.adapter;
2296 loc_eng_data.agps_status_cb = callbacks->status_cb;
2297
2298 loc_eng_data.internet_nif = new AgpsStateMachine(servicerTypeAgps,
2299 (void *)loc_eng_data.agps_status_cb,
2300 AGPS_TYPE_WWAN_ANY,
2301 false);
2302 loc_eng_data.wifi_nif = new AgpsStateMachine(servicerTypeAgps,
2303 (void *)loc_eng_data.agps_status_cb,
2304 AGPS_TYPE_WIFI,
2305 true);
2306
2307 if ((gps_conf.CAPABILITIES & GPS_CAPABILITY_MSA) ||
2308 (gps_conf.CAPABILITIES & GPS_CAPABILITY_MSB)) {
2309 loc_eng_data.agnss_nif = new AgpsStateMachine(servicerTypeAgps,
2310 (void *)loc_eng_data.agps_status_cb,
2311 AGPS_TYPE_SUPL,
2312 false);
2313
2314 if (adapter->mSupportsAgpsRequests) {
2315 if(gps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL) {
2316 loc_eng_data.adapter->sendMsg(new LocEngDataClientInit(&loc_eng_data));
2317 }
2318 loc_eng_dmn_conn_loc_api_server_launch(callbacks->create_thread_cb,
2319 NULL, NULL, &loc_eng_data);
2320 }
2321 loc_eng_agps_reinit(loc_eng_data);
2322 }
2323
2324 EXIT_LOG(%s, VOID_RET);
2325 }
2326
deleteAidingData(loc_eng_data_s_type & logEng)2327 static void deleteAidingData(loc_eng_data_s_type &logEng) {
2328 if (logEng.engine_status != GPS_STATUS_ENGINE_ON &&
2329 logEng.aiding_data_for_deletion != 0) {
2330 logEng.adapter->deleteAidingData(logEng.aiding_data_for_deletion);
2331 logEng.aiding_data_for_deletion = 0;
2332 }
2333 }
2334
2335 static AgpsStateMachine*
getAgpsStateMachine(loc_eng_data_s_type & locEng,AGpsExtType agpsType)2336 getAgpsStateMachine(loc_eng_data_s_type &locEng, AGpsExtType agpsType) {
2337 AgpsStateMachine* stateMachine;
2338 switch (agpsType) {
2339 case AGPS_TYPE_WIFI: {
2340 stateMachine = locEng.wifi_nif;
2341 break;
2342 }
2343 case AGPS_TYPE_INVALID:
2344 case AGPS_TYPE_SUPL: {
2345 stateMachine = locEng.agnss_nif;
2346 break;
2347 }
2348 case AGPS_TYPE_SUPL_ES: {
2349 locEng.ds_nif ?
2350 stateMachine = locEng.ds_nif:
2351 stateMachine = locEng.agnss_nif;
2352 break;
2353 }
2354 default:
2355 stateMachine = locEng.internet_nif;
2356 }
2357 return stateMachine;
2358 }
2359
2360 /*===========================================================================
2361 FUNCTION loc_eng_agps_open
2362
2363 DESCRIPTION
2364 This function is called when on-demand data connection opening is successful.
2365 It should inform engine about the data open result.
2366
2367 DEPENDENCIES
2368 NONE
2369
2370 RETURN VALUE
2371 0
2372
2373 SIDE EFFECTS
2374 N/A
2375
2376 ===========================================================================*/
loc_eng_agps_open(loc_eng_data_s_type & loc_eng_data,AGpsExtType agpsType,const char * apn,AGpsBearerType bearerType)2377 int loc_eng_agps_open(loc_eng_data_s_type &loc_eng_data, AGpsExtType agpsType,
2378 const char* apn, AGpsBearerType bearerType)
2379 {
2380 ENTRY_LOG_CALLFLOW();
2381 INIT_CHECK(loc_eng_data.adapter && loc_eng_data.agps_status_cb,
2382 return -1);
2383
2384 if (apn == NULL)
2385 {
2386 LOC_LOGE("APN Name NULL\n");
2387 return 0;
2388 }
2389
2390 LOC_LOGD("loc_eng_agps_open APN name = [%s]", apn);
2391
2392 int apn_len = smaller_of(strlen (apn), MAX_APN_LEN);
2393 AgpsStateMachine* sm = getAgpsStateMachine(loc_eng_data, agpsType);
2394
2395 loc_eng_data.adapter->sendMsg(
2396 new LocEngAtlOpenSuccess(sm, apn, apn_len, bearerType));
2397
2398 EXIT_LOG(%d, 0);
2399 return 0;
2400 }
2401
2402 /*===========================================================================
2403 FUNCTION loc_eng_agps_closed
2404
2405 DESCRIPTION
2406 This function is called when on-demand data connection closing is done.
2407 It should inform engine about the data close result.
2408
2409 DEPENDENCIES
2410 NONE
2411
2412 RETURN VALUE
2413 0
2414
2415 SIDE EFFECTS
2416 N/A
2417
2418 ===========================================================================*/
loc_eng_agps_closed(loc_eng_data_s_type & loc_eng_data,AGpsExtType agpsType)2419 int loc_eng_agps_closed(loc_eng_data_s_type &loc_eng_data, AGpsExtType agpsType)
2420 {
2421 ENTRY_LOG_CALLFLOW();
2422 INIT_CHECK(loc_eng_data.adapter && loc_eng_data.agps_status_cb,
2423 return -1);
2424
2425 AgpsStateMachine* sm = getAgpsStateMachine(loc_eng_data, agpsType);
2426 loc_eng_data.adapter->sendMsg(new LocEngAtlClosed(sm));
2427
2428 EXIT_LOG(%d, 0);
2429 return 0;
2430 }
2431
2432 /*===========================================================================
2433 FUNCTION loc_eng_agps_open_failed
2434
2435 DESCRIPTION
2436 This function is called when on-demand data connection opening has failed.
2437 It should inform engine about the data open result.
2438
2439 DEPENDENCIES
2440 NONE
2441
2442 RETURN VALUE
2443 0
2444
2445 SIDE EFFECTS
2446 N/A
2447
2448 ===========================================================================*/
loc_eng_agps_open_failed(loc_eng_data_s_type & loc_eng_data,AGpsExtType agpsType)2449 int loc_eng_agps_open_failed(loc_eng_data_s_type &loc_eng_data, AGpsExtType agpsType)
2450 {
2451 ENTRY_LOG_CALLFLOW();
2452 INIT_CHECK(loc_eng_data.adapter && loc_eng_data.agps_status_cb,
2453 return -1);
2454
2455 AgpsStateMachine* sm = getAgpsStateMachine(loc_eng_data, agpsType);
2456 loc_eng_data.adapter->sendMsg(new LocEngAtlOpenFailed(sm));
2457
2458 EXIT_LOG(%d, 0);
2459 return 0;
2460 }
2461
2462 /*===========================================================================
2463
2464 FUNCTION resolve_in_addr
2465
2466 DESCRIPTION
2467 Translates a hostname to in_addr struct
2468
2469 DEPENDENCIES
2470 n/a
2471
2472 RETURN VALUE
2473 TRUE if successful
2474
2475 SIDE EFFECTS
2476 n/a
2477
2478 ===========================================================================*/
resolve_in_addr(const char * host_addr,struct in_addr * in_addr_ptr)2479 static boolean resolve_in_addr(const char *host_addr, struct in_addr *in_addr_ptr)
2480 {
2481 ENTRY_LOG();
2482 boolean ret_val = TRUE;
2483
2484 struct hostent *hp;
2485 hp = gethostbyname(host_addr);
2486 if (hp != NULL) /* DNS OK */
2487 {
2488 memcpy(in_addr_ptr, hp->h_addr_list[0], hp->h_length);
2489 }
2490 else
2491 {
2492 /* Try IP representation */
2493 if (inet_aton(host_addr, in_addr_ptr) == 0)
2494 {
2495 /* IP not valid */
2496 LOC_LOGE("DNS query on '%s' failed\n", host_addr);
2497 ret_val = FALSE;
2498 }
2499 }
2500
2501 EXIT_LOG(%s, loc_logger_boolStr[ret_val!=0]);
2502 return ret_val;
2503 }
2504
2505 /*===========================================================================
2506 FUNCTION loc_eng_set_server
2507
2508 DESCRIPTION
2509 This is used to set the default AGPS server. Server address is obtained
2510 from gps.conf.
2511
2512 DEPENDENCIES
2513 NONE
2514
2515 RETURN VALUE
2516 0
2517
2518 SIDE EFFECTS
2519 N/A
2520
2521 ===========================================================================*/
loc_eng_set_server(loc_eng_data_s_type & loc_eng_data,LocServerType type,const char * hostname,int port)2522 static int loc_eng_set_server(loc_eng_data_s_type &loc_eng_data,
2523 LocServerType type, const char* hostname, int port)
2524 {
2525 ENTRY_LOG();
2526 int ret = 0;
2527 LocEngAdapter* adapter = loc_eng_data.adapter;
2528
2529 if (LOC_AGPS_SUPL_SERVER == type) {
2530 char url[MAX_URL_LEN];
2531 unsigned int len = 0;
2532 const char nohost[] = "NONE";
2533 if (hostname == NULL ||
2534 strncasecmp(nohost, hostname, sizeof(nohost)) == 0) {
2535 url[0] = NULL;
2536 } else {
2537 len = snprintf(url, sizeof(url), "%s:%u", hostname, (unsigned) port);
2538 }
2539
2540 if (sizeof(url) > len) {
2541 adapter->sendMsg(new LocEngSetServerUrl(adapter, url, len));
2542 }
2543 } else if (LOC_AGPS_CDMA_PDE_SERVER == type ||
2544 LOC_AGPS_CUSTOM_PDE_SERVER == type ||
2545 LOC_AGPS_MPC_SERVER == type) {
2546 struct in_addr addr;
2547 if (!resolve_in_addr(hostname, &addr))
2548 {
2549 LOC_LOGE("loc_eng_set_server, hostname %s cannot be resolved.\n", hostname);
2550 ret = -2;
2551 } else {
2552 unsigned int ip = htonl(addr.s_addr);
2553 adapter->sendMsg(new LocEngSetServerIpv4(adapter, ip, port, type));
2554 }
2555 } else {
2556 LOC_LOGE("loc_eng_set_server, type %d cannot be resolved.\n", type);
2557 }
2558
2559 EXIT_LOG(%d, ret);
2560 return ret;
2561 }
2562
2563 /*===========================================================================
2564 FUNCTION loc_eng_set_server_proxy
2565
2566 DESCRIPTION
2567 If loc_eng_set_server is called before loc_eng_init, it doesn't work. This
2568 proxy buffers server settings and calls loc_eng_set_server when the client is
2569 open.
2570
2571 DEPENDENCIES
2572 NONE
2573
2574 RETURN VALUE
2575 0
2576
2577 SIDE EFFECTS
2578 N/A
2579
2580 ===========================================================================*/
loc_eng_set_server_proxy(loc_eng_data_s_type & loc_eng_data,LocServerType type,const char * hostname,int port)2581 int loc_eng_set_server_proxy(loc_eng_data_s_type &loc_eng_data,
2582 LocServerType type,
2583 const char* hostname, int port)
2584 {
2585 ENTRY_LOG_CALLFLOW();
2586 int ret_val = 0;
2587
2588 if (NULL != loc_eng_data.adapter)
2589 {
2590 ret_val = loc_eng_set_server(loc_eng_data, type, hostname, port);
2591 } else {
2592 LOC_LOGW("set_server called before init. save the address, type: %d, hostname: %s, port: %d",
2593 (int) type, hostname, port);
2594 switch (type)
2595 {
2596 case LOC_AGPS_SUPL_SERVER:
2597 strlcpy(loc_eng_data.supl_host_buf, hostname,
2598 sizeof(loc_eng_data.supl_host_buf));
2599 loc_eng_data.supl_port_buf = port;
2600 loc_eng_data.supl_host_set = 1;
2601 break;
2602 case LOC_AGPS_CDMA_PDE_SERVER:
2603 strlcpy(loc_eng_data.c2k_host_buf, hostname,
2604 sizeof(loc_eng_data.c2k_host_buf));
2605 loc_eng_data.c2k_port_buf = port;
2606 loc_eng_data.c2k_host_set = 1;
2607 break;
2608 default:
2609 LOC_LOGE("loc_eng_set_server_proxy, unknown server type = %d", (int) type);
2610 }
2611 }
2612
2613 EXIT_LOG(%d, ret_val);
2614 return ret_val;
2615 }
2616
2617 /*===========================================================================
2618 FUNCTION loc_eng_agps_ril_update_network_availability
2619
2620 DESCRIPTION
2621 Sets data call allow vs disallow flag to modem
2622 This is the only member of sLocEngAGpsRilInterface implemented.
2623
2624 DEPENDENCIES
2625 None
2626
2627 RETURN VALUE
2628 0: success
2629
2630 SIDE EFFECTS
2631 N/A
2632
2633 ===========================================================================*/
loc_eng_agps_ril_update_network_availability(loc_eng_data_s_type & loc_eng_data,int available,const char * apn)2634 void loc_eng_agps_ril_update_network_availability(loc_eng_data_s_type &loc_eng_data,
2635 int available, const char* apn)
2636 {
2637 ENTRY_LOG_CALLFLOW();
2638
2639 //This is to store the status of data availability over the network.
2640 //If GPS is not enabled, the INIT_CHECK will fail and the modem will
2641 //not be updated with the network's availability. Since the data status
2642 //can change before GPS is enabled the, storing the status will enable
2643 //us to inform the modem after GPS is enabled
2644 agpsStatus = available;
2645
2646 INIT_CHECK(loc_eng_data.adapter, return);
2647 if (apn != NULL)
2648 {
2649 LOC_LOGD("loc_eng_agps_ril_update_network_availability: APN Name = [%s]\n", apn);
2650 int apn_len = smaller_of(strlen (apn), MAX_APN_LEN);
2651 LocEngAdapter* adapter = loc_eng_data.adapter;
2652 adapter->sendMsg(new LocEngEnableData(adapter, apn, apn_len, available));
2653 }
2654 EXIT_LOG(%s, VOID_RET);
2655 }
2656
loc_eng_agps_install_certificates(loc_eng_data_s_type & loc_eng_data,const DerEncodedCertificate * certificates,size_t numberOfCerts)2657 int loc_eng_agps_install_certificates(loc_eng_data_s_type &loc_eng_data,
2658 const DerEncodedCertificate* certificates,
2659 size_t numberOfCerts)
2660 {
2661 ENTRY_LOG_CALLFLOW();
2662 int ret_val = AGPS_CERTIFICATE_OPERATION_SUCCESS;
2663
2664 uint32_t slotBitMask = gps_conf.AGPS_CERT_WRITABLE_MASK;
2665 uint32_t slotCount = 0;
2666 for (uint32_t slotBitMaskCounter=slotBitMask; slotBitMaskCounter; slotCount++) {
2667 slotBitMaskCounter &= slotBitMaskCounter - 1;
2668 }
2669 LOC_LOGD("SlotBitMask=%u SlotCount=%u NumberOfCerts=%u",
2670 slotBitMask, slotCount, numberOfCerts);
2671
2672 LocEngAdapter* adapter = loc_eng_data.adapter;
2673
2674 if (numberOfCerts == 0) {
2675 LOC_LOGE("No certs to install, since numberOfCerts is zero");
2676 ret_val = AGPS_CERTIFICATE_OPERATION_SUCCESS;
2677 } else if (!adapter) {
2678 LOC_LOGE("adapter is null!");
2679 ret_val = AGPS_CERTIFICATE_ERROR_GENERIC;
2680 } else if (slotCount < numberOfCerts) {
2681 LOC_LOGE("Not enough cert slots (%u) to install %u certs!",
2682 slotCount, numberOfCerts);
2683 ret_val = AGPS_CERTIFICATE_ERROR_TOO_MANY_CERTIFICATES;
2684 } else {
2685 for (int i=0; i < numberOfCerts; ++i)
2686 {
2687 if (certificates[i].length > AGPS_CERTIFICATE_MAX_LENGTH) {
2688 LOC_LOGE("cert#(%u) length of %u is too big! greater than %u",
2689 certificates[i].length, AGPS_CERTIFICATE_MAX_LENGTH);
2690 ret_val = AGPS_CERTIFICATE_ERROR_GENERIC;
2691 break;
2692 }
2693 }
2694
2695 if (ret_val == AGPS_CERTIFICATE_OPERATION_SUCCESS) {
2696 adapter->sendMsg(new LocEngInstallAGpsCert(adapter,
2697 certificates,
2698 numberOfCerts,
2699 slotBitMask));
2700 }
2701 }
2702
2703 EXIT_LOG(%d, ret_val);
2704 return ret_val;
2705 }
2706
loc_eng_configuration_update(loc_eng_data_s_type & loc_eng_data,const char * config_data,int32_t length)2707 void loc_eng_configuration_update (loc_eng_data_s_type &loc_eng_data,
2708 const char* config_data, int32_t length)
2709 {
2710 ENTRY_LOG_CALLFLOW();
2711
2712 if (config_data && length > 0) {
2713 loc_gps_cfg_s_type gps_conf_tmp = gps_conf;
2714 UTIL_UPDATE_CONF(config_data, length, gps_conf_table);
2715 LocEngAdapter* adapter = loc_eng_data.adapter;
2716
2717 // it is possible that HAL is not init'ed at this time
2718 if (adapter) {
2719 if (gps_conf_tmp.SUPL_VER != gps_conf.SUPL_VER) {
2720 adapter->sendMsg(new LocEngSuplVer(adapter, gps_conf.SUPL_VER));
2721 }
2722 if (gps_conf_tmp.LPP_PROFILE != gps_conf.LPP_PROFILE) {
2723 adapter->sendMsg(new LocEngLppConfig(adapter, gps_conf.LPP_PROFILE));
2724 }
2725 if (gps_conf_tmp.A_GLONASS_POS_PROTOCOL_SELECT != gps_conf.A_GLONASS_POS_PROTOCOL_SELECT) {
2726 adapter->sendMsg(new LocEngAGlonassProtocol(adapter,
2727 gps_conf.A_GLONASS_POS_PROTOCOL_SELECT));
2728 }
2729 if (gps_conf_tmp.SUPL_MODE != gps_conf.SUPL_MODE) {
2730 adapter->sendMsg(new LocEngSuplMode(adapter->getUlpProxy()));
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 // modem is back up. If we crashed in the middle of navigating, we restart.
2855 if (loc_eng_data.adapter->isInSession()) {
2856 // This sets the copy in adapter to modem
2857 loc_eng_data.adapter->setPositionMode(NULL);
2858 loc_eng_data.adapter->setInSession(false);
2859 loc_eng_start_handler(loc_eng_data);
2860 }
2861 EXIT_LOG(%s, VOID_RET);
2862 }
2863
2864 #ifdef USE_GLIB
2865 /*===========================================================================
2866 FUNCTION set_sched_policy
2867
2868 DESCRIPTION
2869 Local copy of this function which bypasses android set_sched_policy
2870
2871 DEPENDENCIES
2872 None
2873
2874 RETURN VALUE
2875 0
2876
2877 SIDE EFFECTS
2878 N/A
2879
2880 ===========================================================================*/
set_sched_policy(int tid,SchedPolicy policy)2881 static int set_sched_policy(int tid, SchedPolicy policy)
2882 {
2883 return 0;
2884 }
2885 #endif /* USE_GLIB */
2886
2887 /*===========================================================================
2888 FUNCTION loc_eng_read_config
2889
2890 DESCRIPTION
2891 Initiates the reading of the gps config file stored in /etc dir
2892
2893 DEPENDENCIES
2894 None
2895
2896 RETURN VALUE
2897 0: success
2898
2899 SIDE EFFECTS
2900 N/A
2901
2902 ===========================================================================*/
loc_eng_read_config(void)2903 int loc_eng_read_config(void)
2904 {
2905 ENTRY_LOG_CALLFLOW();
2906 if(configAlreadyRead == false)
2907 {
2908 // Initialize our defaults before reading of configuration file overwrites them.
2909 loc_default_parameters();
2910 // We only want to parse the conf file once. This is a good place to ensure that.
2911 // In fact one day the conf file should go into context.
2912 UTIL_READ_CONF(GPS_CONF_FILE, gps_conf_table);
2913 UTIL_READ_CONF(SAP_CONF_FILE, sap_conf_table);
2914 configAlreadyRead = true;
2915 } else {
2916 LOC_LOGV("GPS Config file has already been read\n");
2917 }
2918
2919 EXIT_LOG(%d, 0);
2920 return 0;
2921 }
2922
2923 /*===========================================================================
2924 FUNCTION loc_eng_gps_measurement_init
2925
2926 DESCRIPTION
2927 Initialize gps measurement module.
2928
2929 DEPENDENCIES
2930 N/A
2931
2932 RETURN VALUE
2933 0: success
2934
2935 SIDE EFFECTS
2936 N/A
2937
2938 ===========================================================================*/
loc_eng_gps_measurement_init(loc_eng_data_s_type & loc_eng_data,GpsMeasurementCallbacks * callbacks)2939 int loc_eng_gps_measurement_init(loc_eng_data_s_type &loc_eng_data,
2940 GpsMeasurementCallbacks* callbacks)
2941 {
2942 ENTRY_LOG_CALLFLOW();
2943
2944 STATE_CHECK((NULL == loc_eng_data.gps_measurement_cb),
2945 "gps measurement already initialized",
2946 return GPS_MEASUREMENT_ERROR_ALREADY_INIT);
2947 STATE_CHECK((callbacks != NULL),
2948 "callbacks can not be NULL",
2949 return GPS_MEASUREMENT_ERROR_GENERIC);
2950 STATE_CHECK(loc_eng_data.adapter,
2951 "GpsInterface must be initialized first",
2952 return GPS_MEASUREMENT_ERROR_GENERIC);
2953
2954 // updated the mask
2955 LOC_API_ADAPTER_EVENT_MASK_T event = LOC_API_ADAPTER_BIT_GNSS_MEASUREMENT;
2956 loc_eng_data.adapter->sendMsg(new LocEngUpdateRegistrationMask(
2957 &loc_eng_data,
2958 event,
2959 LOC_REGISTRATION_MASK_ENABLED));
2960 // set up the callback
2961 loc_eng_data.gps_measurement_cb = callbacks->measurement_callback;
2962 LOC_LOGD ("%s, event masks updated successfully", __func__);
2963
2964 return GPS_MEASUREMENT_OPERATION_SUCCESS;
2965 }
2966
2967 /*===========================================================================
2968 FUNCTION loc_eng_gps_measurement_close
2969
2970 DESCRIPTION
2971 Close gps measurement module.
2972
2973 DEPENDENCIES
2974 N/A
2975
2976 RETURN VALUE
2977 N/A
2978
2979 SIDE EFFECTS
2980 N/A
2981
2982 ===========================================================================*/
loc_eng_gps_measurement_close(loc_eng_data_s_type & loc_eng_data)2983 void loc_eng_gps_measurement_close(loc_eng_data_s_type &loc_eng_data)
2984 {
2985 ENTRY_LOG_CALLFLOW();
2986
2987 INIT_CHECK(loc_eng_data.adapter, return);
2988
2989 // updated the mask
2990 LOC_API_ADAPTER_EVENT_MASK_T event = LOC_API_ADAPTER_BIT_GNSS_MEASUREMENT;
2991 loc_eng_data.adapter->sendMsg(new LocEngUpdateRegistrationMask(
2992 &loc_eng_data,
2993 event,
2994 LOC_REGISTRATION_MASK_DISABLED));
2995 // set up the callback
2996 loc_eng_data.gps_measurement_cb = NULL;
2997 EXIT_LOG(%d, 0);
2998 }
2999