1 /* Copyright (c) 2009-2016, The Linux Foundation. All rights reserved.
2 *
3 * Redistribution and use in source and binary forms, with or without
4 * modification, are permitted provided that the following conditions are
5 * met:
6 * * Redistributions of source code must retain the above copyright
7 * notice, this list of conditions and the following disclaimer.
8 * * Redistributions in binary form must reproduce the above
9 * copyright notice, this list of conditions and the following
10 * disclaimer in the documentation and/or other materials provided
11 * with the distribution.
12 * * Neither the name of The Linux Foundation, nor the names of its
13 * contributors may be used to endorse or promote products derived
14 * from this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
18 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
20 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
23 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
24 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
25 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
26 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 *
28 */
29
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
94 /* Parameter spec table */
95 static const loc_param_s_type gps_conf_table[] =
96 {
97 {"GPS_LOCK", &gps_conf.GPS_LOCK, NULL, 'n'},
98 {"SUPL_VER", &gps_conf.SUPL_VER, NULL, 'n'},
99 {"LPP_PROFILE", &gps_conf.LPP_PROFILE, NULL, 'n'},
100 {"A_GLONASS_POS_PROTOCOL_SELECT", &gps_conf.A_GLONASS_POS_PROTOCOL_SELECT, NULL, 'n'},
101 {"AGPS_CERT_WRITABLE_MASK", &gps_conf.AGPS_CERT_WRITABLE_MASK, NULL, 'n'},
102 {"SUPL_MODE", &gps_conf.SUPL_MODE, NULL, 'n'},
103 {"INTERMEDIATE_POS", &gps_conf.INTERMEDIATE_POS, NULL, 'n'},
104 {"ACCURACY_THRES", &gps_conf.ACCURACY_THRES, NULL, 'n'},
105 {"NMEA_PROVIDER", &gps_conf.NMEA_PROVIDER, NULL, 'n'},
106 {"CAPABILITIES", &gps_conf.CAPABILITIES, NULL, 'n'},
107 {"XTRA_VERSION_CHECK", &gps_conf.XTRA_VERSION_CHECK, NULL, 'n'},
108 {"XTRA_SERVER_1", &gps_conf.XTRA_SERVER_1, NULL, 's'},
109 {"XTRA_SERVER_2", &gps_conf.XTRA_SERVER_2, NULL, 's'},
110 {"XTRA_SERVER_3", &gps_conf.XTRA_SERVER_3, NULL, 's'},
111 {"USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL", &gps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL, NULL, 'n'},
112 };
113
114 static const loc_param_s_type sap_conf_table[] =
115 {
116 {"GYRO_BIAS_RANDOM_WALK", &sap_conf.GYRO_BIAS_RANDOM_WALK, &sap_conf.GYRO_BIAS_RANDOM_WALK_VALID, 'f'},
117 {"ACCEL_RANDOM_WALK_SPECTRAL_DENSITY", &sap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY, &sap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY_VALID, 'f'},
118 {"ANGLE_RANDOM_WALK_SPECTRAL_DENSITY", &sap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY, &sap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY_VALID, 'f'},
119 {"RATE_RANDOM_WALK_SPECTRAL_DENSITY", &sap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY, &sap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY_VALID, 'f'},
120 {"VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY", &sap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY, &sap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY_VALID, 'f'},
121 {"SENSOR_ACCEL_BATCHES_PER_SEC", &sap_conf.SENSOR_ACCEL_BATCHES_PER_SEC, NULL, 'n'},
122 {"SENSOR_ACCEL_SAMPLES_PER_BATCH", &sap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH, NULL, 'n'},
123 {"SENSOR_GYRO_BATCHES_PER_SEC", &sap_conf.SENSOR_GYRO_BATCHES_PER_SEC, NULL, 'n'},
124 {"SENSOR_GYRO_SAMPLES_PER_BATCH", &sap_conf.SENSOR_GYRO_SAMPLES_PER_BATCH, NULL, 'n'},
125 {"SENSOR_ACCEL_BATCHES_PER_SEC_HIGH", &sap_conf.SENSOR_ACCEL_BATCHES_PER_SEC_HIGH, NULL, 'n'},
126 {"SENSOR_ACCEL_SAMPLES_PER_BATCH_HIGH", &sap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH_HIGH, NULL, 'n'},
127 {"SENSOR_GYRO_BATCHES_PER_SEC_HIGH", &sap_conf.SENSOR_GYRO_BATCHES_PER_SEC_HIGH, NULL, 'n'},
128 {"SENSOR_GYRO_SAMPLES_PER_BATCH_HIGH", &sap_conf.SENSOR_GYRO_SAMPLES_PER_BATCH_HIGH, NULL, 'n'},
129 {"SENSOR_CONTROL_MODE", &sap_conf.SENSOR_CONTROL_MODE, NULL, 'n'},
130 {"SENSOR_USAGE", &sap_conf.SENSOR_USAGE, NULL, 'n'},
131 {"SENSOR_ALGORITHM_CONFIG_MASK", &sap_conf.SENSOR_ALGORITHM_CONFIG_MASK, NULL, 'n'},
132 {"SENSOR_PROVIDER", &sap_conf.SENSOR_PROVIDER, NULL, 'n'}
133 };
134
loc_default_parameters(void)135 static void loc_default_parameters(void)
136 {
137 /*Defaults for gps.conf*/
138 gps_conf.INTERMEDIATE_POS = 0;
139 gps_conf.ACCURACY_THRES = 0;
140 gps_conf.NMEA_PROVIDER = 0;
141 gps_conf.GPS_LOCK = 0;
142 gps_conf.SUPL_VER = 0x10000;
143 gps_conf.SUPL_MODE = 0x3;
144 gps_conf.CAPABILITIES = 0x7;
145 /* LTE Positioning Profile configuration is disable by default*/
146 gps_conf.LPP_PROFILE = 0;
147 /*By default no positioning protocol is selected on A-GLONASS system*/
148 gps_conf.A_GLONASS_POS_PROTOCOL_SELECT = 0;
149 /*XTRA version check is disabled by default*/
150 gps_conf.XTRA_VERSION_CHECK=0;
151 /*Use emergency PDN by default*/
152 gps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL = 1;
153
154 /*Defaults for sap.conf*/
155 sap_conf.GYRO_BIAS_RANDOM_WALK = 0;
156 sap_conf.SENSOR_ACCEL_BATCHES_PER_SEC = 2;
157 sap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH = 5;
158 sap_conf.SENSOR_GYRO_BATCHES_PER_SEC = 2;
159 sap_conf.SENSOR_GYRO_SAMPLES_PER_BATCH = 5;
160 sap_conf.SENSOR_ACCEL_BATCHES_PER_SEC_HIGH = 4;
161 sap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH_HIGH = 25;
162 sap_conf.SENSOR_GYRO_BATCHES_PER_SEC_HIGH = 4;
163 sap_conf.SENSOR_GYRO_SAMPLES_PER_BATCH_HIGH = 25;
164 sap_conf.SENSOR_CONTROL_MODE = 0; /* AUTO */
165 sap_conf.SENSOR_USAGE = 0; /* Enabled */
166 sap_conf.SENSOR_ALGORITHM_CONFIG_MASK = 0; /* INS Disabled = FALSE*/
167 /* Values MUST be set by OEMs in configuration for sensor-assisted
168 navigation to work. There are NO default values */
169 sap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY = 0;
170 sap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY = 0;
171 sap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY = 0;
172 sap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY = 0;
173 sap_conf.GYRO_BIAS_RANDOM_WALK_VALID = 0;
174 sap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY_VALID = 0;
175 sap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY_VALID = 0;
176 sap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY_VALID = 0;
177 sap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY_VALID = 0;
178 /* default provider is SSC */
179 sap_conf.SENSOR_PROVIDER = 1;
180
181 /* None of the 10 slots for agps certificates are writable by default */
182 gps_conf.AGPS_CERT_WRITABLE_MASK = 0;
183 }
184
185 // 2nd half of init(), singled out for
186 // modem restart to use.
187 static int loc_eng_reinit(loc_eng_data_s_type &loc_eng_data);
188 static void loc_eng_agps_reinit(loc_eng_data_s_type &loc_eng_data);
189
190 static int loc_eng_set_server(loc_eng_data_s_type &loc_eng_data,
191 LocServerType type, const char *hostname, int port);
192 // Internal functions
193 static void loc_inform_gps_status(loc_eng_data_s_type &loc_eng_data,
194 GpsStatusValue status);
195 static void loc_eng_report_status(loc_eng_data_s_type &loc_eng_data,
196 GpsStatusValue status);
197 static void loc_eng_process_conn_request(loc_eng_data_s_type &loc_eng_data,
198 int connHandle, AGpsType agps_type);
199 static void loc_eng_agps_close_status(loc_eng_data_s_type &loc_eng_data, int is_succ);
200 static void loc_eng_handle_engine_down(loc_eng_data_s_type &loc_eng_data) ;
201 static void loc_eng_handle_engine_up(loc_eng_data_s_type &loc_eng_data) ;
202
203 static int loc_eng_start_handler(loc_eng_data_s_type &loc_eng_data);
204 static int loc_eng_stop_handler(loc_eng_data_s_type &loc_eng_data);
205 static int loc_eng_get_zpp_handler(loc_eng_data_s_type &loc_eng_data);
206 static void deleteAidingData(loc_eng_data_s_type &logEng);
207 static AgpsStateMachine*
208 getAgpsStateMachine(loc_eng_data_s_type& logEng, AGpsExtType agpsType);
209 static int dataCallCb(void *cb_data);
update_aiding_data_for_deletion(loc_eng_data_s_type & loc_eng_data)210 static void update_aiding_data_for_deletion(loc_eng_data_s_type& loc_eng_data) {
211 if (loc_eng_data.engine_status != GPS_STATUS_ENGINE_ON &&
212 loc_eng_data.aiding_data_for_deletion != 0)
213 {
214 loc_eng_data.adapter->deleteAidingData(loc_eng_data.aiding_data_for_deletion);
215 loc_eng_data.aiding_data_for_deletion = 0;
216 }
217 }
218
noProc(void * data)219 static void* noProc(void* data)
220 {
221 return NULL;
222 }
223
224 /*********************************************************************
225 * definitions of the static messages used in the file
226 *********************************************************************/
227 // case LOC_ENG_MSG_REQUEST_NI:
LocEngRequestNi(void * locEng,GpsNiNotification & notif,const void * data)228 LocEngRequestNi::LocEngRequestNi(void* locEng,
229 GpsNiNotification ¬if,
230 const void* data) :
231 LocMsg(), mLocEng(locEng), mNotify(notif), mPayload(data) {
232 locallog();
233 }
proc() const234 void LocEngRequestNi::proc() const {
235 loc_eng_ni_request_handler(*((loc_eng_data_s_type*)mLocEng),
236 &mNotify, mPayload);
237 }
locallog() const238 void LocEngRequestNi::locallog() const
239 {
240 LOC_LOGV("id: %d\n type: %s\n flags: %d\n time out: %d\n "
241 "default response: %s\n requestor id encoding: %s\n"
242 " text encoding: %s\n passThroughData: %p",
243 mNotify.notification_id,
244 loc_get_ni_type_name(mNotify.ni_type),
245 mNotify.notify_flags,
246 mNotify.timeout,
247 loc_get_ni_response_name(mNotify.default_response),
248 loc_get_ni_encoding_name(mNotify.requestor_id_encoding),
249 loc_get_ni_encoding_name(mNotify.text_encoding),
250 mPayload);
251 }
log() const252 inline void LocEngRequestNi::log() const {
253 locallog();
254 }
255
256 // case LOC_ENG_MSG_INFORM_NI_RESPONSE:
257 // in loc_eng_ni.cpp
258
259 // case LOC_ENG_MSG_START_FIX:
LocEngStartFix(LocEngAdapter * adapter)260 LocEngStartFix::LocEngStartFix(LocEngAdapter* adapter) :
261 LocMsg(), mAdapter(adapter)
262 {
263 locallog();
264 }
proc() const265 inline void LocEngStartFix::proc() const
266 {
267 loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mAdapter->getOwner();
268 loc_eng_start_handler(*locEng);
269 }
locallog() const270 inline void LocEngStartFix::locallog() const
271 {
272 LOC_LOGV("LocEngStartFix");
273 }
log() const274 inline void LocEngStartFix::log() const
275 {
276 locallog();
277 }
send() const278 void LocEngStartFix::send() const {
279 mAdapter->sendMsg(this);
280 }
281
282 // case LOC_ENG_MSG_STOP_FIX:
LocEngStopFix(LocEngAdapter * adapter)283 LocEngStopFix::LocEngStopFix(LocEngAdapter* adapter) :
284 LocMsg(), mAdapter(adapter)
285 {
286 locallog();
287 }
proc() const288 inline void LocEngStopFix::proc() const
289 {
290 loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mAdapter->getOwner();
291 loc_eng_stop_handler(*locEng);
292 }
locallog() const293 inline void LocEngStopFix::locallog() const
294 {
295 LOC_LOGV("LocEngStopFix");
296 }
log() const297 inline void LocEngStopFix::log() const
298 {
299 locallog();
300 }
send() const301 void LocEngStopFix::send() const {
302 mAdapter->sendMsg(this);
303 }
304
305 // case LOC_ENG_MSG_SET_POSITION_MODE:
LocEngPositionMode(LocEngAdapter * adapter,LocPosMode & mode)306 LocEngPositionMode::LocEngPositionMode(LocEngAdapter* adapter,
307 LocPosMode &mode) :
308 LocMsg(), mAdapter(adapter), mPosMode(mode)
309 {
310 mPosMode.logv();
311 }
proc() const312 inline void LocEngPositionMode::proc() const {
313 mAdapter->setPositionMode(&mPosMode);
314 }
log() const315 inline void LocEngPositionMode::log() const {
316 mPosMode.logv();
317 }
send() const318 void LocEngPositionMode::send() const {
319 mAdapter->sendMsg(this);
320 }
321
LocEngGetZpp(LocEngAdapter * adapter)322 LocEngGetZpp::LocEngGetZpp(LocEngAdapter* adapter) :
323 LocMsg(), mAdapter(adapter)
324 {
325 locallog();
326 }
proc() const327 inline void LocEngGetZpp::proc() const
328 {
329 loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mAdapter->getOwner();
330 loc_eng_get_zpp_handler(*locEng);
331 }
locallog() const332 inline void LocEngGetZpp::locallog() const
333 {
334 LOC_LOGV("LocEngGetZpp");
335 }
log() const336 inline void LocEngGetZpp::log() const
337 {
338 locallog();
339 }
send() const340 void LocEngGetZpp::send() const {
341 mAdapter->sendMsg(this);
342 }
343
344 struct LocEngSetTime : public LocMsg {
345 LocEngAdapter* mAdapter;
346 const GpsUtcTime mTime;
347 const int64_t mTimeReference;
348 const int mUncertainty;
LocEngSetTimeLocEngSetTime349 inline LocEngSetTime(LocEngAdapter* adapter,
350 GpsUtcTime t, int64_t tf, int unc) :
351 LocMsg(), mAdapter(adapter),
352 mTime(t), mTimeReference(tf), mUncertainty(unc)
353 {
354 locallog();
355 }
procLocEngSetTime356 inline virtual void proc() const {
357 mAdapter->setTime(mTime, mTimeReference, mUncertainty);
358 }
locallogLocEngSetTime359 inline void locallog() const {
360 LOC_LOGV("time: %lld\n timeReference: %lld\n uncertainty: %d",
361 mTime, mTimeReference, mUncertainty);
362 }
logLocEngSetTime363 inline virtual void log() const {
364 locallog();
365 }
366 };
367
368 // case LOC_ENG_MSG_INJECT_LOCATION:
369 struct LocEngInjectLocation : public LocMsg {
370 LocEngAdapter* mAdapter;
371 const double mLatitude;
372 const double mLongitude;
373 const float mAccuracy;
LocEngInjectLocationLocEngInjectLocation374 inline LocEngInjectLocation(LocEngAdapter* adapter,
375 double lat, double lon, float accur) :
376 LocMsg(), mAdapter(adapter),
377 mLatitude(lat), mLongitude(lon), mAccuracy(accur)
378 {
379 locallog();
380 }
procLocEngInjectLocation381 inline virtual void proc() const {
382 mAdapter->injectPosition(mLatitude, mLongitude, mAccuracy);
383 }
locallogLocEngInjectLocation384 inline void locallog() const {
385 LOC_LOGV("latitude: %f\n longitude: %f\n accuracy: %f",
386 mLatitude, mLongitude, mAccuracy);
387 }
logLocEngInjectLocation388 inline virtual void log() const {
389 locallog();
390 }
391 };
392
393 // case LOC_ENG_MSG_SET_SERVER_IPV4:
394 struct LocEngSetServerIpv4 : public LocMsg {
395 LocEngAdapter* mAdapter;
396 const unsigned int mNlAddr;
397 const int mPort;
398 const LocServerType mServerType;
LocEngSetServerIpv4LocEngSetServerIpv4399 inline LocEngSetServerIpv4(LocEngAdapter* adapter,
400 unsigned int ip,
401 int port,
402 LocServerType type) :
403 LocMsg(), mAdapter(adapter),
404 mNlAddr(ip), mPort(port), mServerType(type)
405 {
406 locallog();
407 }
procLocEngSetServerIpv4408 inline virtual void proc() const {
409 mAdapter->setServer(mNlAddr, mPort, mServerType);
410 }
locallogLocEngSetServerIpv4411 inline void locallog() const {
412 LOC_LOGV("LocEngSetServerIpv4 - addr: %x, port: %d, type: %s",
413 mNlAddr, mPort, loc_get_server_type_name(mServerType));
414 }
logLocEngSetServerIpv4415 inline virtual void log() const {
416 locallog();
417 }
418 };
419
420 // case LOC_ENG_MSG_SET_SERVER_URL:
421 struct LocEngSetServerUrl : public LocMsg {
422 LocEngAdapter* mAdapter;
423 const int mLen;
424 char* mUrl;
LocEngSetServerUrlLocEngSetServerUrl425 inline LocEngSetServerUrl(LocEngAdapter* adapter,
426 char* urlString,
427 int url_len) :
428 LocMsg(), mAdapter(adapter),
429 mLen(url_len), mUrl(new char[mLen+1])
430 {
431 memcpy((void*)mUrl, (void*)urlString, url_len);
432 mUrl[mLen] = 0;
433 locallog();
434 }
~LocEngSetServerUrlLocEngSetServerUrl435 inline ~LocEngSetServerUrl()
436 {
437 delete[] mUrl;
438 }
procLocEngSetServerUrl439 inline virtual void proc() const {
440 mAdapter->setServer(mUrl, mLen);
441 }
locallogLocEngSetServerUrl442 inline void locallog() const {
443 LOC_LOGV("LocEngSetServerUrl - url: %s", mUrl);
444 }
logLocEngSetServerUrl445 inline virtual void log() const {
446 locallog();
447 }
448 };
449
450 // case LOC_ENG_MSG_A_GLONASS_PROTOCOL:
451 struct LocEngAGlonassProtocol : public LocMsg {
452 LocEngAdapter* mAdapter;
453 const unsigned long mAGlonassProtocl;
LocEngAGlonassProtocolLocEngAGlonassProtocol454 inline LocEngAGlonassProtocol(LocEngAdapter* adapter,
455 unsigned long protocol) :
456 LocMsg(), mAdapter(adapter), mAGlonassProtocl(protocol)
457 {
458 locallog();
459 }
procLocEngAGlonassProtocol460 inline virtual void proc() const {
461 mAdapter->setAGLONASSProtocol(mAGlonassProtocl);
462 }
locallogLocEngAGlonassProtocol463 inline void locallog() const {
464 LOC_LOGV("A-GLONASS protocol: 0x%lx", mAGlonassProtocl);
465 }
logLocEngAGlonassProtocol466 inline virtual void log() const {
467 locallog();
468 }
469 };
470
471 // case LOC_ENG_MSG_SUPL_VERSION:
472 struct LocEngSuplVer : public LocMsg {
473 LocEngAdapter* mAdapter;
474 const int mSuplVer;
LocEngSuplVerLocEngSuplVer475 inline LocEngSuplVer(LocEngAdapter* adapter,
476 int suplVer) :
477 LocMsg(), mAdapter(adapter), mSuplVer(suplVer)
478 {
479 locallog();
480 }
procLocEngSuplVer481 inline virtual void proc() const {
482 mAdapter->setSUPLVersion(mSuplVer);
483 }
locallogLocEngSuplVer484 inline void locallog() const {
485 LOC_LOGV("SUPL Version: %d", mSuplVer);
486 }
logLocEngSuplVer487 inline virtual void log() const {
488 locallog();
489 }
490 };
491
492 struct LocEngSuplMode : public LocMsg {
493 UlpProxyBase* mUlp;
494
LocEngSuplModeLocEngSuplMode495 inline LocEngSuplMode(UlpProxyBase* ulp) :
496 LocMsg(), mUlp(ulp)
497 {
498 locallog();
499 }
procLocEngSuplMode500 inline virtual void proc() const {
501 mUlp->setCapabilities(ContextBase::getCarrierCapabilities());
502 }
locallogLocEngSuplMode503 inline void locallog() const {
504 }
logLocEngSuplMode505 inline virtual void log() const {
506 locallog();
507 }
508 };
509
510 // case LOC_ENG_MSG_LPP_CONFIG:
511 struct LocEngLppConfig : public LocMsg {
512 LocEngAdapter* mAdapter;
513 const int mLppConfig;
LocEngLppConfigLocEngLppConfig514 inline LocEngLppConfig(LocEngAdapter* adapter,
515 int lppConfig) :
516 LocMsg(), mAdapter(adapter), mLppConfig(lppConfig)
517 {
518 locallog();
519 }
procLocEngLppConfig520 inline virtual void proc() const {
521 mAdapter->setLPPConfig(mLppConfig);
522 }
locallogLocEngLppConfig523 inline void locallog() const {
524 LOC_LOGV("LocEngLppConfig - profile: %d", mLppConfig);
525 }
logLocEngLppConfig526 inline virtual void log() const {
527 locallog();
528 }
529 };
530
531 // case LOC_ENG_MSG_SET_SENSOR_CONTROL_CONFIG:
532 struct LocEngSensorControlConfig : public LocMsg {
533 LocEngAdapter* mAdapter;
534 const int mSensorsDisabled;
535 const int mSensorProvider;
LocEngSensorControlConfigLocEngSensorControlConfig536 inline LocEngSensorControlConfig(LocEngAdapter* adapter,
537 int sensorsDisabled, int sensorProvider) :
538 LocMsg(), mAdapter(adapter), mSensorsDisabled(sensorsDisabled),
539 mSensorProvider(sensorProvider)
540 {
541 locallog();
542 }
procLocEngSensorControlConfig543 inline virtual void proc() const {
544 mAdapter->setSensorControlConfig(mSensorsDisabled, mSensorProvider);
545 }
locallogLocEngSensorControlConfig546 inline void locallog() const {
547 LOC_LOGV("LocEngSensorControlConfig - Sensors Disabled: %d, Sensor Provider: %d",
548 mSensorsDisabled, mSensorProvider);
549 }
logLocEngSensorControlConfig550 inline virtual void log() const {
551 locallog();
552 }
553 };
554
555 // case LOC_ENG_MSG_SET_SENSOR_PROPERTIES:
556 struct LocEngSensorProperties : public LocMsg {
557 LocEngAdapter* mAdapter;
558 const bool mGyroBiasVarianceRandomWalkValid;
559 const float mGyroBiasVarianceRandomWalk;
560 const bool mAccelRandomWalkValid;
561 const float mAccelRandomWalk;
562 const bool mAngleRandomWalkValid;
563 const float mAngleRandomWalk;
564 const bool mRateRandomWalkValid;
565 const float mRateRandomWalk;
566 const bool mVelocityRandomWalkValid;
567 const float mVelocityRandomWalk;
LocEngSensorPropertiesLocEngSensorProperties568 inline LocEngSensorProperties(LocEngAdapter* adapter,
569 bool gyroBiasRandomWalk_valid,
570 float gyroBiasRandomWalk,
571 bool accelRandomWalk_valid,
572 float accelRandomWalk,
573 bool angleRandomWalk_valid,
574 float angleRandomWalk,
575 bool rateRandomWalk_valid,
576 float rateRandomWalk,
577 bool velocityRandomWalk_valid,
578 float velocityRandomWalk) :
579 LocMsg(), mAdapter(adapter),
580 mGyroBiasVarianceRandomWalkValid(gyroBiasRandomWalk_valid),
581 mGyroBiasVarianceRandomWalk(gyroBiasRandomWalk),
582 mAccelRandomWalkValid(accelRandomWalk_valid),
583 mAccelRandomWalk(accelRandomWalk),
584 mAngleRandomWalkValid(angleRandomWalk_valid),
585 mAngleRandomWalk(angleRandomWalk),
586 mRateRandomWalkValid(rateRandomWalk_valid),
587 mRateRandomWalk(rateRandomWalk),
588 mVelocityRandomWalkValid(velocityRandomWalk_valid),
589 mVelocityRandomWalk(velocityRandomWalk)
590 {
591 locallog();
592 }
procLocEngSensorProperties593 inline virtual void proc() const {
594 mAdapter->setSensorProperties(mGyroBiasVarianceRandomWalkValid,
595 mGyroBiasVarianceRandomWalk,
596 mAccelRandomWalkValid,
597 mAccelRandomWalk,
598 mAngleRandomWalkValid,
599 mAngleRandomWalk,
600 mRateRandomWalkValid,
601 mRateRandomWalk,
602 mVelocityRandomWalkValid,
603 mVelocityRandomWalk);
604 }
locallogLocEngSensorProperties605 inline void locallog() const {
606 LOC_LOGV("Sensor properties validity, Gyro Random walk: %d "
607 "Accel Random Walk: %d "
608 "Angle Random Walk: %d Rate Random Walk: %d "
609 "Velocity Random Walk: %d\n"
610 "Sensor properties, Gyro Random walk: %f "
611 "Accel Random Walk: %f "
612 "Angle Random Walk: %f Rate Random Walk: %f "
613 "Velocity Random Walk: %f",
614 mGyroBiasVarianceRandomWalkValid,
615 mAccelRandomWalkValid,
616 mAngleRandomWalkValid,
617 mRateRandomWalkValid,
618 mVelocityRandomWalkValid,
619 mGyroBiasVarianceRandomWalk,
620 mAccelRandomWalk,
621 mAngleRandomWalk,
622 mRateRandomWalk,
623 mVelocityRandomWalk
624 );
625 }
logLocEngSensorProperties626 inline virtual void log() const {
627 locallog();
628 }
629 };
630
631 // case LOC_ENG_MSG_SET_SENSOR_PERF_CONTROL_CONFIG:
632 struct LocEngSensorPerfControlConfig : public LocMsg {
633 LocEngAdapter* mAdapter;
634 const int mControlMode;
635 const int mAccelSamplesPerBatch;
636 const int mAccelBatchesPerSec;
637 const int mGyroSamplesPerBatch;
638 const int mGyroBatchesPerSec;
639 const int mAccelSamplesPerBatchHigh;
640 const int mAccelBatchesPerSecHigh;
641 const int mGyroSamplesPerBatchHigh;
642 const int mGyroBatchesPerSecHigh;
643 const int mAlgorithmConfig;
LocEngSensorPerfControlConfigLocEngSensorPerfControlConfig644 inline LocEngSensorPerfControlConfig(LocEngAdapter* adapter,
645 int controlMode,
646 int accelSamplesPerBatch,
647 int accelBatchesPerSec,
648 int gyroSamplesPerBatch,
649 int gyroBatchesPerSec,
650 int accelSamplesPerBatchHigh,
651 int accelBatchesPerSecHigh,
652 int gyroSamplesPerBatchHigh,
653 int gyroBatchesPerSecHigh,
654 int algorithmConfig) :
655 LocMsg(), mAdapter(adapter),
656 mControlMode(controlMode),
657 mAccelSamplesPerBatch(accelSamplesPerBatch),
658 mAccelBatchesPerSec(accelBatchesPerSec),
659 mGyroSamplesPerBatch(gyroSamplesPerBatch),
660 mGyroBatchesPerSec(gyroBatchesPerSec),
661 mAccelSamplesPerBatchHigh(accelSamplesPerBatchHigh),
662 mAccelBatchesPerSecHigh(accelBatchesPerSecHigh),
663 mGyroSamplesPerBatchHigh(gyroSamplesPerBatchHigh),
664 mGyroBatchesPerSecHigh(gyroBatchesPerSecHigh),
665 mAlgorithmConfig(algorithmConfig)
666 {
667 locallog();
668 }
procLocEngSensorPerfControlConfig669 inline virtual void proc() const {
670 mAdapter->setSensorPerfControlConfig(mControlMode,
671 mAccelSamplesPerBatch,
672 mAccelBatchesPerSec,
673 mGyroSamplesPerBatch,
674 mGyroBatchesPerSec,
675 mAccelSamplesPerBatchHigh,
676 mAccelBatchesPerSecHigh,
677 mGyroSamplesPerBatchHigh,
678 mGyroBatchesPerSecHigh,
679 mAlgorithmConfig);
680 }
locallogLocEngSensorPerfControlConfig681 inline void locallog() const {
682 LOC_LOGV("Sensor Perf Control Config (performanceControlMode)(%u) "
683 "accel(#smp,#batches) (%u,%u) "
684 "gyro(#smp,#batches) (%u,%u), "
685 "accel_high(#smp,#batches) (%u,%u) "
686 "gyro_high(#smp,#batches) (%u,%u), "
687 "algorithmConfig(%u)\n",
688 mControlMode,
689 mAccelSamplesPerBatch, mAccelBatchesPerSec,
690 mGyroSamplesPerBatch, mGyroBatchesPerSec,
691 mAccelSamplesPerBatchHigh, mAccelBatchesPerSecHigh,
692 mGyroSamplesPerBatchHigh, mGyroBatchesPerSecHigh,
693 mAlgorithmConfig);
694 }
logLocEngSensorPerfControlConfig695 inline virtual void log() const {
696 locallog();
697 }
698 };
699
700 // case LOC_ENG_MSG_EXT_POWER_CONFIG:
701 struct LocEngExtPowerConfig : public LocMsg {
702 LocEngAdapter* mAdapter;
703 const int mIsBatteryCharging;
LocEngExtPowerConfigLocEngExtPowerConfig704 inline LocEngExtPowerConfig(LocEngAdapter* adapter,
705 int isBatteryCharging) :
706 LocMsg(), mAdapter(adapter),
707 mIsBatteryCharging(isBatteryCharging)
708 {
709 locallog();
710 }
procLocEngExtPowerConfig711 inline virtual void proc() const {
712 mAdapter->setExtPowerConfig(mIsBatteryCharging);
713 }
locallogLocEngExtPowerConfig714 inline void locallog() const {
715 LOC_LOGV("LocEngExtPowerConfig - isBatteryCharging: %d",
716 mIsBatteryCharging);
717 }
logLocEngExtPowerConfig718 inline virtual void log() const {
719 locallog();
720 }
721 };
722
723 // case LOC_ENG_MSG_REPORT_POSITION:
LocEngReportPosition(LocAdapterBase * adapter,UlpLocation & loc,GpsLocationExtended & locExtended,void * locExt,enum loc_sess_status st,LocPosTechMask technology)724 LocEngReportPosition::LocEngReportPosition(LocAdapterBase* adapter,
725 UlpLocation &loc,
726 GpsLocationExtended &locExtended,
727 void* locExt,
728 enum loc_sess_status st,
729 LocPosTechMask technology) :
730 LocMsg(), mAdapter(adapter), mLocation(loc),
731 mLocationExtended(locExtended),
732 mLocationExt(((loc_eng_data_s_type*)
733 ((LocEngAdapter*)
734 (mAdapter))->getOwner())->location_ext_parser(locExt)),
735 mStatus(st), mTechMask(technology)
736 {
737 locallog();
738 }
proc() const739 void LocEngReportPosition::proc() const {
740 LocEngAdapter* adapter = (LocEngAdapter*)mAdapter;
741 loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)adapter->getOwner();
742
743 if (locEng->mute_session_state != LOC_MUTE_SESS_IN_SESSION) {
744 bool reported = false;
745 if (locEng->location_cb != NULL) {
746 if (LOC_SESS_FAILURE == mStatus) {
747 // in case we want to handle the failure case
748 locEng->location_cb(NULL, NULL);
749 reported = true;
750 }
751 // what's in the else if is... (line by line)
752 // 1. this is a final fix; and
753 // 1.1 it is a Satellite fix; or
754 // 1.2 it is a sensor fix
755 // 2. (must be intermediate fix... implicit)
756 // 2.1 we accepte intermediate; and
757 // 2.2 it is NOT the case that
758 // 2.2.1 there is inaccuracy; and
759 // 2.2.2 we care about inaccuracy; and
760 // 2.2.3 the inaccuracy exceeds our tolerance
761 else if ((LOC_SESS_SUCCESS == mStatus &&
762 ((LOC_POS_TECH_MASK_SATELLITE |
763 LOC_POS_TECH_MASK_SENSORS |
764 LOC_POS_TECH_MASK_HYBRID) &
765 mTechMask)) ||
766 (LOC_SESS_INTERMEDIATE == locEng->intermediateFix &&
767 !((mLocation.gpsLocation.flags &
768 GPS_LOCATION_HAS_ACCURACY) &&
769 (gps_conf.ACCURACY_THRES != 0) &&
770 (mLocation.gpsLocation.accuracy >
771 gps_conf.ACCURACY_THRES)))) {
772 locEng->location_cb((UlpLocation*)&(mLocation),
773 (void*)mLocationExt);
774 reported = true;
775 }
776 }
777
778 // if we have reported this fix
779 if (reported &&
780 // and if this is a singleshot
781 GPS_POSITION_RECURRENCE_SINGLE ==
782 locEng->adapter->getPositionMode().recurrence) {
783 if (LOC_SESS_INTERMEDIATE == mStatus) {
784 // modem could be still working for a final fix,
785 // although we no longer need it. So stopFix().
786 locEng->adapter->stopFix();
787 }
788 // turn off the session flag.
789 locEng->adapter->setInSession(false);
790 }
791
792 LOC_LOGV("LocEngReportPosition::proc() - generateNmea: %d, position source: %d, "
793 "engine_status: %d, isInSession: %d",
794 locEng->generateNmea, mLocation.position_source,
795 locEng->engine_status, locEng->adapter->isInSession());
796
797 if (locEng->generateNmea &&
798 locEng->adapter->isInSession())
799 {
800 unsigned char generate_nmea = reported &&
801 (mStatus != LOC_SESS_FAILURE);
802 loc_eng_nmea_generate_pos(locEng, mLocation, mLocationExtended,
803 generate_nmea);
804 }
805
806 // Free the allocated memory for rawData
807 UlpLocation* gp = (UlpLocation*)&(mLocation);
808 if (gp != NULL && gp->rawData != NULL)
809 {
810 delete (char*)gp->rawData;
811 gp->rawData = NULL;
812 gp->rawDataSize = 0;
813 }
814 }
815 }
locallog() const816 void LocEngReportPosition::locallog() const {
817 LOC_LOGV("LocEngReportPosition");
818 }
log() const819 void LocEngReportPosition::log() const {
820 locallog();
821 }
send() const822 void LocEngReportPosition::send() const {
823 mAdapter->sendMsg(this);
824 }
825
826
827 // case LOC_ENG_MSG_REPORT_SV:
LocEngReportSv(LocAdapterBase * adapter,GnssSvStatus & sv,GpsLocationExtended & locExtended,void * svExt)828 LocEngReportSv::LocEngReportSv(LocAdapterBase* adapter,
829 GnssSvStatus &sv,
830 GpsLocationExtended &locExtended,
831 void* svExt) :
832 LocMsg(), mAdapter(adapter), mSvStatus(sv),
833 mLocationExtended(locExtended),
834 mSvExt(((loc_eng_data_s_type*)
835 ((LocEngAdapter*)
836 (mAdapter))->getOwner())->sv_ext_parser(svExt))
837 {
838 locallog();
839 }
proc() const840 void LocEngReportSv::proc() const {
841 LocEngAdapter* adapter = (LocEngAdapter*)mAdapter;
842 loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)adapter->getOwner();
843
844 if (locEng->mute_session_state != LOC_MUTE_SESS_IN_SESSION)
845 {
846 if (locEng->gnss_sv_status_cb != NULL) {
847 locEng->gnss_sv_status_cb((GnssSvStatus*)&(mSvStatus));
848 }
849
850 if (locEng->generateNmea)
851 {
852 loc_eng_nmea_generate_sv(locEng, mSvStatus, mLocationExtended);
853 }
854 }
855 }
locallog() const856 void LocEngReportSv::locallog() const {
857 LOC_LOGV("%s:%d] LocEngReportSv",__func__, __LINE__);
858 }
log() const859 inline void LocEngReportSv::log() const {
860 locallog();
861 }
send() const862 void LocEngReportSv::send() const {
863 mAdapter->sendMsg(this);
864 }
865
866 // case LOC_ENG_MSG_REPORT_STATUS:
LocEngReportStatus(LocAdapterBase * adapter,GpsStatusValue engineStatus)867 LocEngReportStatus::LocEngReportStatus(LocAdapterBase* adapter,
868 GpsStatusValue engineStatus) :
869 LocMsg(), mAdapter(adapter), mStatus(engineStatus)
870 {
871 locallog();
872 }
proc() const873 inline void LocEngReportStatus::proc() const
874 {
875 LocEngAdapter* adapter = (LocEngAdapter*)mAdapter;
876 loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)adapter->getOwner();
877
878 loc_eng_report_status(*locEng, mStatus);
879 update_aiding_data_for_deletion(*locEng);
880 }
locallog() const881 inline void LocEngReportStatus::locallog() const {
882 LOC_LOGV("LocEngReportStatus");
883 }
log() const884 inline void LocEngReportStatus::log() const {
885 locallog();
886 }
887
888 // case LOC_ENG_MSG_REPORT_NMEA:
LocEngReportNmea(void * locEng,const char * data,int len)889 LocEngReportNmea::LocEngReportNmea(void* locEng,
890 const char* data, int len) :
891 LocMsg(), mLocEng(locEng), mNmea(new char[len]), mLen(len)
892 {
893 memcpy((void*)mNmea, (void*)data, len);
894 locallog();
895 }
proc() const896 void LocEngReportNmea::proc() const {
897 loc_eng_data_s_type* locEng = (loc_eng_data_s_type*) mLocEng;
898
899 struct timeval tv;
900 gettimeofday(&tv, (struct timezone *) NULL);
901 int64_t now = tv.tv_sec * 1000LL + tv.tv_usec / 1000;
902
903 if (locEng->nmea_cb != NULL)
904 locEng->nmea_cb(now, mNmea, mLen);
905 }
locallog() const906 inline void LocEngReportNmea::locallog() const {
907 LOC_LOGV("LocEngReportNmea");
908 }
log() const909 inline void LocEngReportNmea::log() const {
910 locallog();
911 }
912
913 // case LOC_ENG_MSG_REPORT_XTRA_SERVER:
LocEngReportXtraServer(void * locEng,const char * url1,const char * url2,const char * url3,const int maxlength)914 LocEngReportXtraServer::LocEngReportXtraServer(void* locEng,
915 const char *url1,
916 const char *url2,
917 const char *url3,
918 const int maxlength) :
919 LocMsg(), mLocEng(locEng), mMaxLen(maxlength),
920 mServers(new char[3*(mMaxLen+1)])
921 {
922 char * cptr = mServers;
923 memset(mServers, 0, 3*(mMaxLen+1));
924
925 // Override modem URLs with uncommented gps.conf urls
926 if( gps_conf.XTRA_SERVER_1[0] != '\0' ) {
927 url1 = &gps_conf.XTRA_SERVER_1[0];
928 }
929 if( gps_conf.XTRA_SERVER_2[0] != '\0' ) {
930 url2 = &gps_conf.XTRA_SERVER_2[0];
931 }
932 if( gps_conf.XTRA_SERVER_3[0] != '\0' ) {
933 url3 = &gps_conf.XTRA_SERVER_3[0];
934 }
935 // copy non xtra1.gpsonextra.net URLs into the forwarding buffer.
936 if( NULL == strcasestr(url1, XTRA1_GPSONEXTRA) ) {
937 strlcpy(cptr, url1, mMaxLen + 1);
938 cptr += mMaxLen + 1;
939 }
940 if( NULL == strcasestr(url2, XTRA1_GPSONEXTRA) ) {
941 strlcpy(cptr, url2, mMaxLen + 1);
942 cptr += mMaxLen + 1;
943 }
944 if( NULL == strcasestr(url3, XTRA1_GPSONEXTRA) ) {
945 strlcpy(cptr, url3, mMaxLen + 1);
946 }
947 locallog();
948 }
949
proc() const950 void LocEngReportXtraServer::proc() const {
951 loc_eng_xtra_data_s_type* locEngXtra =
952 &(((loc_eng_data_s_type*)mLocEng)->xtra_module_data);
953
954 if (locEngXtra->report_xtra_server_cb != NULL) {
955 CALLBACK_LOG_CALLFLOW("report_xtra_server_cb", %s, mServers);
956 locEngXtra->report_xtra_server_cb(mServers,
957 &(mServers[mMaxLen+1]),
958 &(mServers[(mMaxLen+1)<<1]));
959 } else {
960 LOC_LOGE("Callback function for request xtra is NULL");
961 }
962 }
locallog() const963 inline void LocEngReportXtraServer::locallog() const {
964 LOC_LOGV("LocEngReportXtraServers: server1: %s\n server2: %s\n"
965 " server3: %s\n",
966 mServers, &mServers[mMaxLen+1], &mServers[(mMaxLen+1)<<1]);
967 }
log() const968 inline void LocEngReportXtraServer::log() const {
969 locallog();
970 }
971
972 // case LOC_ENG_MSG_REQUEST_BIT:
973 // case LOC_ENG_MSG_RELEASE_BIT:
LocEngReqRelBIT(void * locEng,AGpsExtType type,int ipv4,char * ipv6,bool isReq)974 LocEngReqRelBIT::LocEngReqRelBIT(void* locEng, AGpsExtType type,
975 int ipv4, char* ipv6, bool isReq) :
976 LocMsg(), mLocEng(locEng), mType(type), mIPv4Addr(ipv4),
977 mIPv6Addr(ipv6 ? new char[16] : NULL), mIsReq(isReq) {
978 if (NULL != ipv6)
979 memcpy(mIPv6Addr, ipv6, 16);
980 locallog();
981 }
~LocEngReqRelBIT()982 inline LocEngReqRelBIT::~LocEngReqRelBIT() {
983 if (mIPv6Addr) {
984 delete[] mIPv6Addr;
985 }
986 }
proc() const987 void LocEngReqRelBIT::proc() const {
988 loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
989 BITSubscriber s(getAgpsStateMachine(*locEng, mType),
990 mIPv4Addr, mIPv6Addr);
991 AgpsStateMachine* sm = (AgpsStateMachine*)s.mStateMachine;
992
993 if (mIsReq) {
994 sm->subscribeRsrc((Subscriber*)&s);
995 } else {
996 sm->unsubscribeRsrc((Subscriber*)&s);
997 }
998 }
locallog() const999 inline void LocEngReqRelBIT::locallog() const {
1000 LOC_LOGV("LocEngRequestBIT - ipv4: %d.%d.%d.%d, ipv6: %s",
1001 (unsigned char)mIPv4Addr,
1002 (unsigned char)(mIPv4Addr>>8),
1003 (unsigned char)(mIPv4Addr>>16),
1004 (unsigned char)(mIPv4Addr>>24),
1005 NULL != mIPv6Addr ? mIPv6Addr : "");
1006 }
log() const1007 inline void LocEngReqRelBIT::log() const {
1008 locallog();
1009 }
send() const1010 void LocEngReqRelBIT::send() const {
1011 loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
1012 locEng->adapter->sendMsg(this);
1013 }
1014
1015 // case LOC_ENG_MSG_RELEASE_BIT:
1016 struct LocEngReleaseBIT : public LocMsg {
1017 const BITSubscriber mSubscriber;
LocEngReleaseBITLocEngReleaseBIT1018 inline LocEngReleaseBIT(const AgpsStateMachine* stateMachine,
1019 unsigned int ipv4, char* ipv6) :
1020 LocMsg(),
1021 mSubscriber(stateMachine, ipv4, ipv6)
1022 {
1023 locallog();
1024 }
procLocEngReleaseBIT1025 inline virtual void proc() const
1026 {
1027 AgpsStateMachine* sm = (AgpsStateMachine*)mSubscriber.mStateMachine;
1028 sm->unsubscribeRsrc((Subscriber*)&mSubscriber);
1029 }
locallogLocEngReleaseBIT1030 inline void locallog() const {
1031 LOC_LOGV("LocEngReleaseBIT - ipv4: %d.%d.%d.%d, ipv6: %s",
1032 (unsigned char)(mSubscriber.ID>>24),
1033 (unsigned char)(mSubscriber.ID>>16),
1034 (unsigned char)(mSubscriber.ID>>8),
1035 (unsigned char)mSubscriber.ID,
1036 NULL != mSubscriber.mIPv6Addr ? mSubscriber.mIPv6Addr : "");
1037 }
logLocEngReleaseBIT1038 virtual void log() const {
1039 locallog();
1040 }
1041 };
1042
1043 // LocEngSuplEsOpened
LocEngSuplEsOpened(void * locEng)1044 LocEngSuplEsOpened::LocEngSuplEsOpened(void* locEng) :
1045 LocMsg(), mLocEng(locEng) {
1046 locallog();
1047 }
proc() const1048 void LocEngSuplEsOpened::proc() const {
1049 loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
1050 if (locEng->ds_nif) {
1051 AgpsStateMachine* sm = locEng->ds_nif;
1052 sm->onRsrcEvent(RSRC_GRANTED);
1053 }
1054 }
locallog() const1055 void LocEngSuplEsOpened::locallog() const {
1056 LOC_LOGV("LocEngSuplEsOpened");
1057 }
log() const1058 void LocEngSuplEsOpened::log() const {
1059 locallog();
1060 }
1061
1062 // LocEngSuplEsClosed
LocEngSuplEsClosed(void * locEng)1063 LocEngSuplEsClosed::LocEngSuplEsClosed(void* locEng) :
1064 LocMsg(), mLocEng(locEng) {
1065 locallog();
1066 }
proc() const1067 void LocEngSuplEsClosed::proc() const {
1068 loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
1069 if (locEng->ds_nif) {
1070 AgpsStateMachine* sm = locEng->ds_nif;
1071 sm->onRsrcEvent(RSRC_RELEASED);
1072 }
1073 }
locallog() const1074 void LocEngSuplEsClosed::locallog() const {
1075 LOC_LOGV("LocEngSuplEsClosed");
1076 }
log() const1077 void LocEngSuplEsClosed::log() const {
1078 locallog();
1079 }
1080
1081
1082 // case LOC_ENG_MSG_REQUEST_SUPL_ES:
LocEngRequestSuplEs(void * locEng,int id)1083 LocEngRequestSuplEs::LocEngRequestSuplEs(void* locEng, int id) :
1084 LocMsg(), mLocEng(locEng), mID(id) {
1085 locallog();
1086 }
proc() const1087 void LocEngRequestSuplEs::proc() const {
1088 loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
1089 if (locEng->ds_nif) {
1090 AgpsStateMachine* sm = locEng->ds_nif;
1091 DSSubscriber s(sm, mID);
1092 sm->subscribeRsrc((Subscriber*)&s);
1093 }
1094 else if (locEng->agnss_nif) {
1095 AgpsStateMachine *sm = locEng->agnss_nif;
1096 ATLSubscriber s(mID,
1097 sm,
1098 locEng->adapter,
1099 false);
1100 sm->subscribeRsrc((Subscriber*)&s);
1101 LOC_LOGD("%s:%d]: Using regular ATL for SUPL ES", __func__, __LINE__);
1102 }
1103 else {
1104 locEng->adapter->atlOpenStatus(mID, 0, NULL, -1, -1);
1105 }
1106 }
locallog() const1107 inline void LocEngRequestSuplEs::locallog() const {
1108 LOC_LOGV("LocEngRequestSuplEs");
1109 }
log() const1110 inline void LocEngRequestSuplEs::log() const {
1111 locallog();
1112 }
1113
1114 // case LOC_ENG_MSG_REQUEST_ATL:
LocEngRequestATL(void * locEng,int id,AGpsExtType agps_type)1115 LocEngRequestATL::LocEngRequestATL(void* locEng, int id,
1116 AGpsExtType agps_type) :
1117 LocMsg(), mLocEng(locEng), mID(id), mType(agps_type) {
1118 locallog();
1119 }
proc() const1120 void LocEngRequestATL::proc() const {
1121 loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
1122 AgpsStateMachine* sm = (AgpsStateMachine*)
1123 getAgpsStateMachine(*locEng, mType);
1124 if (sm) {
1125 ATLSubscriber s(mID,
1126 sm,
1127 locEng->adapter,
1128 AGPS_TYPE_INVALID == mType);
1129 sm->subscribeRsrc((Subscriber*)&s);
1130 } else {
1131 locEng->adapter->atlOpenStatus(mID, 0, NULL, -1, mType);
1132 }
1133 }
locallog() const1134 inline void LocEngRequestATL::locallog() const {
1135 LOC_LOGV("LocEngRequestATL");
1136 }
log() const1137 inline void LocEngRequestATL::log() const {
1138 locallog();
1139 }
1140
1141 // case LOC_ENG_MSG_RELEASE_ATL:
LocEngReleaseATL(void * locEng,int id)1142 LocEngReleaseATL::LocEngReleaseATL(void* locEng, int id) :
1143 LocMsg(), mLocEng(locEng), mID(id) {
1144 locallog();
1145 }
proc() const1146 void LocEngReleaseATL::proc() const {
1147 loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
1148
1149 if (locEng->agnss_nif) {
1150 ATLSubscriber s1(mID, locEng->agnss_nif, locEng->adapter, false);
1151 if (locEng->agnss_nif->unsubscribeRsrc((Subscriber*)&s1)) {
1152 LOC_LOGD("%s:%d]: Unsubscribed from agnss_nif",
1153 __func__, __LINE__);
1154 return;
1155 }
1156 }
1157
1158 if (locEng->internet_nif) {
1159 ATLSubscriber s2(mID, locEng->internet_nif, locEng->adapter, false);
1160 if (locEng->internet_nif->unsubscribeRsrc((Subscriber*)&s2)) {
1161 LOC_LOGD("%s:%d]: Unsubscribed from internet_nif",
1162 __func__, __LINE__);
1163 return;
1164 }
1165 }
1166
1167 if (locEng->ds_nif) {
1168 DSSubscriber s3(locEng->ds_nif, mID);
1169 if (locEng->ds_nif->unsubscribeRsrc((Subscriber*)&s3)) {
1170 LOC_LOGD("%s:%d]: Unsubscribed from ds_nif",
1171 __func__, __LINE__);
1172 return;
1173 }
1174 }
1175
1176 LOC_LOGW("%s:%d]: Could not release ATL. "
1177 "No subscribers found\n",
1178 __func__, __LINE__);
1179 locEng->adapter->atlCloseStatus(mID, 0);
1180 }
locallog() const1181 inline void LocEngReleaseATL::locallog() const {
1182 LOC_LOGV("LocEngReleaseATL");
1183 }
log() const1184 inline void LocEngReleaseATL::log() const {
1185 locallog();
1186 }
1187
1188 // case LOC_ENG_MSG_REQUEST_WIFI:
1189 // 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)1190 LocEngReqRelWifi::LocEngReqRelWifi(void* locEng, AGpsExtType type,
1191 loc_if_req_sender_id_e_type sender_id,
1192 char* s, char* p, bool isReq) :
1193 LocMsg(), mLocEng(locEng), mType(type), mSenderId(sender_id),
1194 mSSID(NULL == s ? NULL : new char[SSID_BUF_SIZE]),
1195 mPassword(NULL == p ? NULL : new char[SSID_BUF_SIZE]),
1196 mIsReq(isReq) {
1197 if (NULL != s)
1198 strlcpy(mSSID, s, SSID_BUF_SIZE);
1199 if (NULL != p)
1200 strlcpy(mPassword, p, SSID_BUF_SIZE);
1201 locallog();
1202 }
~LocEngReqRelWifi()1203 LocEngReqRelWifi::~LocEngReqRelWifi() {
1204 if (NULL != mSSID) {
1205 delete[] mSSID;
1206 }
1207 if (NULL != mPassword) {
1208 delete[] mPassword;
1209 }
1210 }
proc() const1211 void LocEngReqRelWifi::proc() const {
1212 loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
1213 if (locEng->wifi_nif) {
1214 WIFISubscriber s(locEng->wifi_nif, mSSID, mPassword, mSenderId);
1215 if (mIsReq) {
1216 locEng->wifi_nif->subscribeRsrc((Subscriber*)&s);
1217 } else {
1218 locEng->wifi_nif->unsubscribeRsrc((Subscriber*)&s);
1219 }
1220 } else {
1221 locEng->adapter->atlOpenStatus(mSenderId, 0, NULL, -1, mType);
1222 }
1223 }
locallog() const1224 inline void LocEngReqRelWifi::locallog() const {
1225 LOC_LOGV("%s - senderId: %d, ssid: %s, password: %s",
1226 mIsReq ? "LocEngRequestWifi" : "LocEngReleaseWifi",
1227 mSenderId,
1228 NULL != mSSID ? mSSID : "",
1229 NULL != mPassword ? mPassword : "");
1230 }
log() const1231 inline void LocEngReqRelWifi::log() const {
1232 locallog();
1233 }
send() const1234 void LocEngReqRelWifi::send() const {
1235 loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
1236 locEng->adapter->sendMsg(this);
1237 }
1238
1239 // case LOC_ENG_MSG_REQUEST_XTRA_DATA:
LocEngRequestXtra(void * locEng)1240 LocEngRequestXtra::LocEngRequestXtra(void* locEng) :
1241 mLocEng(locEng) {
1242 locallog();
1243 }
proc() const1244 void LocEngRequestXtra::proc() const
1245 {
1246 loc_eng_xtra_data_s_type* locEngXtra =
1247 &(((loc_eng_data_s_type*)mLocEng)->xtra_module_data);
1248
1249 if (locEngXtra->download_request_cb != NULL) {
1250 CALLBACK_LOG_CALLFLOW("download_request_cb", %p, mLocEng);
1251 locEngXtra->download_request_cb();
1252 } else {
1253 LOC_LOGE("Callback function for request xtra is NULL");
1254 }
1255 }
locallog() const1256 inline void LocEngRequestXtra::locallog() const {
1257 LOC_LOGV("LocEngReqXtra");
1258 }
log() const1259 inline void LocEngRequestXtra::log() const {
1260 locallog();
1261 }
1262
1263 // case LOC_ENG_MSG_REQUEST_TIME:
LocEngRequestTime(void * locEng)1264 LocEngRequestTime::LocEngRequestTime(void* locEng) :
1265 LocMsg(), mLocEng(locEng)
1266 {
1267 locallog();
1268 }
proc() const1269 void LocEngRequestTime::proc() const {
1270 loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
1271 if (gps_conf.CAPABILITIES & GPS_CAPABILITY_ON_DEMAND_TIME) {
1272 if (locEng->request_utc_time_cb != NULL) {
1273 locEng->request_utc_time_cb();
1274 } else {
1275 LOC_LOGE("Callback function for request time is NULL");
1276 }
1277 }
1278 }
locallog() const1279 inline void LocEngRequestTime::locallog() const {
1280 LOC_LOGV("LocEngReqTime");
1281 }
log() const1282 inline void LocEngRequestTime::log() const {
1283 locallog();
1284 }
1285
1286 // case LOC_ENG_MSG_DELETE_AIDING_DATA:
1287 struct LocEngDelAidData : public LocMsg {
1288 loc_eng_data_s_type* mLocEng;
1289 const GpsAidingData mType;
LocEngDelAidDataLocEngDelAidData1290 inline LocEngDelAidData(loc_eng_data_s_type* locEng,
1291 GpsAidingData f) :
1292 LocMsg(), mLocEng(locEng), mType(f)
1293 {
1294 locallog();
1295 }
procLocEngDelAidData1296 inline virtual void proc() const {
1297 mLocEng->aiding_data_for_deletion = mType;
1298 update_aiding_data_for_deletion(*mLocEng);
1299 }
locallogLocEngDelAidData1300 inline void locallog() const {
1301 LOC_LOGV("aiding data msak %d", mType);
1302 }
logLocEngDelAidData1303 virtual void log() const {
1304 locallog();
1305 }
1306 };
1307
1308 // case LOC_ENG_MSG_ENABLE_DATA:
1309 struct LocEngEnableData : public LocMsg {
1310 LocEngAdapter* mAdapter;
1311 const int mEnable;
1312 char* mAPN;
1313 const int mLen;
LocEngEnableDataLocEngEnableData1314 inline LocEngEnableData(LocEngAdapter* adapter,
1315 const char* name, int len, int enable) :
1316 LocMsg(), mAdapter(adapter),
1317 mEnable(enable), mAPN(NULL), mLen(len)
1318 {
1319 if (NULL != name) {
1320 mAPN = new char[len+1];
1321 memcpy((void*)mAPN, (void*)name, len);
1322 mAPN[len] = 0;
1323 }
1324 locallog();
1325 }
~LocEngEnableDataLocEngEnableData1326 inline ~LocEngEnableData() {
1327 if (NULL != mAPN) {
1328 delete[] mAPN;
1329 }
1330 }
procLocEngEnableData1331 inline virtual void proc() const {
1332 mAdapter->enableData(mEnable);
1333 if (NULL != mAPN) {
1334 mAdapter->setAPN(mAPN, mLen);
1335 }
1336 }
locallogLocEngEnableData1337 inline void locallog() const {
1338 LOC_LOGV("apn: %s\n enable: %d",
1339 (NULL == mAPN) ? "NULL" : mAPN, mEnable);
1340 }
logLocEngEnableData1341 inline virtual void log() const {
1342 locallog();
1343 }
1344 };
1345
1346 // case LOC_ENG_MSG_INJECT_XTRA_DATA:
1347 // loc_eng_xtra.cpp
1348
1349 // case LOC_ENG_MSG_SET_CAPABILITIES:
1350 struct LocEngSetCapabilities : public LocMsg {
1351 loc_eng_data_s_type* mLocEng;
LocEngSetCapabilitiesLocEngSetCapabilities1352 inline LocEngSetCapabilities(loc_eng_data_s_type* locEng) :
1353 LocMsg(), mLocEng(locEng)
1354 {
1355 locallog();
1356 }
procLocEngSetCapabilities1357 inline virtual void proc() const {
1358 if (NULL != mLocEng->set_capabilities_cb) {
1359 LOC_LOGV("calling set_capabilities_cb 0x%x",
1360 gps_conf.CAPABILITIES);
1361 mLocEng->set_capabilities_cb(gps_conf.CAPABILITIES);
1362 } else {
1363 LOC_LOGV("set_capabilities_cb is NULL.\n");
1364 }
1365 }
locallogLocEngSetCapabilities1366 inline void locallog() const
1367 {
1368 LOC_LOGV("LocEngSetCapabilities");
1369 }
logLocEngSetCapabilities1370 inline virtual void log() const
1371 {
1372 locallog();
1373 }
1374 };
1375
1376 struct LocEngSetSystemInfo : public LocMsg {
1377 loc_eng_data_s_type* mLocEng;
LocEngSetSystemInfoLocEngSetSystemInfo1378 inline LocEngSetSystemInfo(loc_eng_data_s_type* locEng) :
1379 LocMsg(), mLocEng(locEng)
1380 {
1381 locallog();
1382 }
procLocEngSetSystemInfo1383 inline virtual void proc() const {
1384 if (NULL != mLocEng->set_system_info_cb) {
1385 LOC_LOGV("calling set_system_info_cb 0x%x",
1386 mLocEng->adapter->mGnssInfo.year_of_hw);
1387 mLocEng->set_system_info_cb(&(mLocEng->adapter->mGnssInfo));
1388 }
1389 else {
1390 LOC_LOGV("set_system_info_cb is NULL.\n");
1391 }
1392 }
locallogLocEngSetSystemInfo1393 inline void locallog() const
1394 {
1395 LOC_LOGV("LocEngSetSystemInfo");
1396 }
logLocEngSetSystemInfo1397 inline virtual void log() const
1398 {
1399 locallog();
1400 }
1401 };
1402
1403 // case LOC_ENG_MSG_LOC_INIT:
1404 struct LocEngInit : public LocMsg {
1405 loc_eng_data_s_type* mLocEng;
LocEngInitLocEngInit1406 inline LocEngInit(loc_eng_data_s_type* locEng) :
1407 LocMsg(), mLocEng(locEng)
1408 {
1409 locallog();
1410 }
procLocEngInit1411 inline virtual void proc() const {
1412 loc_eng_reinit(*mLocEng);
1413 // set the capabilities
1414 mLocEng->adapter->sendMsg(new LocEngSetCapabilities(mLocEng));
1415 mLocEng->adapter->sendMsg(new LocEngSetSystemInfo(mLocEng));
1416 }
locallogLocEngInit1417 inline void locallog() const
1418 {
1419 LOC_LOGV("LocEngInit");
1420 }
logLocEngInit1421 inline virtual void log() const
1422 {
1423 locallog();
1424 }
1425 };
1426
1427 // case LOC_ENG_MSG_REQUEST_XTRA_SERVER:
1428 // loc_eng_xtra.cpp
1429
1430 // case LOC_ENG_MSG_ATL_OPEN_SUCCESS:
1431 struct LocEngAtlOpenSuccess : public LocMsg {
1432 AgpsStateMachine* mStateMachine;
1433 const int mLen;
1434 char* mAPN;
1435 const AGpsBearerType mBearerType;
LocEngAtlOpenSuccessLocEngAtlOpenSuccess1436 inline LocEngAtlOpenSuccess(AgpsStateMachine* statemachine,
1437 const char* name,
1438 int len,
1439 AGpsBearerType btype) :
1440 LocMsg(),
1441 mStateMachine(statemachine), mLen(len),
1442 mAPN(new char[len+1]), mBearerType(btype)
1443 {
1444 memcpy((void*)mAPN, (void*)name, len);
1445 mAPN[len] = 0;
1446 locallog();
1447 }
~LocEngAtlOpenSuccessLocEngAtlOpenSuccess1448 inline ~LocEngAtlOpenSuccess()
1449 {
1450 delete[] mAPN;
1451 }
procLocEngAtlOpenSuccess1452 inline virtual void proc() const {
1453 mStateMachine->setBearer(mBearerType);
1454 mStateMachine->setAPN(mAPN, mLen);
1455 mStateMachine->onRsrcEvent(RSRC_GRANTED);
1456 }
locallogLocEngAtlOpenSuccess1457 inline void locallog() const {
1458 LOC_LOGV("LocEngAtlOpenSuccess agps type: %s\n apn: %s\n"
1459 " bearer type: %s",
1460 loc_get_agps_type_name(mStateMachine->getType()),
1461 mAPN,
1462 loc_get_agps_bear_name(mBearerType));
1463 }
logLocEngAtlOpenSuccess1464 inline virtual void log() const {
1465 locallog();
1466 }
1467 };
1468
1469 // case LOC_ENG_MSG_ATL_CLOSED:
1470 struct LocEngAtlClosed : public LocMsg {
1471 AgpsStateMachine* mStateMachine;
LocEngAtlClosedLocEngAtlClosed1472 inline LocEngAtlClosed(AgpsStateMachine* statemachine) :
1473 LocMsg(), mStateMachine(statemachine) {
1474 locallog();
1475 }
procLocEngAtlClosed1476 inline virtual void proc() const {
1477 mStateMachine->onRsrcEvent(RSRC_RELEASED);
1478 }
locallogLocEngAtlClosed1479 inline void locallog() const {
1480 LOC_LOGV("LocEngAtlClosed");
1481 }
logLocEngAtlClosed1482 inline virtual void log() const {
1483 locallog();
1484 }
1485 };
1486
1487 // case LOC_ENG_MSG_ATL_OPEN_FAILED:
1488 struct LocEngAtlOpenFailed : public LocMsg {
1489 AgpsStateMachine* mStateMachine;
LocEngAtlOpenFailedLocEngAtlOpenFailed1490 inline LocEngAtlOpenFailed(AgpsStateMachine* statemachine) :
1491 LocMsg(), mStateMachine(statemachine) {
1492 locallog();
1493 }
procLocEngAtlOpenFailed1494 inline virtual void proc() const {
1495 mStateMachine->onRsrcEvent(RSRC_DENIED);
1496 }
locallogLocEngAtlOpenFailed1497 inline void locallog() const {
1498 LOC_LOGV("LocEngAtlOpenFailed");
1499 }
logLocEngAtlOpenFailed1500 inline virtual void log() const {
1501 locallog();
1502 }
1503 };
1504
1505 // case LOC_ENG_MSG_ENGINE_DOWN:
LocEngDown(void * locEng)1506 LocEngDown::LocEngDown(void* locEng) :
1507 LocMsg(), mLocEng(locEng) {
1508 locallog();
1509 }
proc() const1510 inline void LocEngDown::proc() const {
1511 loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
1512 loc_eng_handle_engine_down(*locEng);
1513 }
locallog() const1514 inline void LocEngDown::locallog() const {
1515 LOC_LOGV("LocEngDown");
1516 }
log() const1517 inline void LocEngDown::log() const {
1518 locallog();
1519 }
1520
1521 // case LOC_ENG_MSG_ENGINE_UP:
LocEngUp(void * locEng)1522 LocEngUp::LocEngUp(void* locEng) :
1523 LocMsg(), mLocEng(locEng) {
1524 locallog();
1525 }
proc() const1526 inline void LocEngUp::proc() const {
1527 loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
1528 loc_eng_handle_engine_up(*locEng);
1529 }
locallog() const1530 inline void LocEngUp::locallog() const {
1531 LOC_LOGV("LocEngUp");
1532 }
log() const1533 inline void LocEngUp::log() const {
1534 locallog();
1535 }
1536
1537 struct LocEngDataClientInit : public LocMsg {
1538 loc_eng_data_s_type* mLocEng;
LocEngDataClientInitLocEngDataClientInit1539 inline LocEngDataClientInit(loc_eng_data_s_type* locEng) :
1540 LocMsg(), mLocEng(locEng) {
1541 locallog();
1542 }
procLocEngDataClientInit1543 virtual void proc() const {
1544 loc_eng_data_s_type *locEng = (loc_eng_data_s_type *)mLocEng;
1545 if(!locEng->adapter->initDataServiceClient()) {
1546 locEng->ds_nif = new DSStateMachine(servicerTypeExt,
1547 (void *)dataCallCb,
1548 locEng->adapter);
1549 }
1550 }
locallogLocEngDataClientInit1551 void locallog() const {
1552 LOC_LOGV("LocEngDataClientInit\n");
1553 }
logLocEngDataClientInit1554 virtual void log() const {
1555 locallog();
1556 }
1557 };
1558
1559 struct LocEngInstallAGpsCert : public LocMsg {
1560 LocEngAdapter* mpAdapter;
1561 const size_t mNumberOfCerts;
1562 const uint32_t mSlotBitMask;
1563 DerEncodedCertificate* mpData;
LocEngInstallAGpsCertLocEngInstallAGpsCert1564 inline LocEngInstallAGpsCert(LocEngAdapter* adapter,
1565 const DerEncodedCertificate* pData,
1566 size_t numberOfCerts,
1567 uint32_t slotBitMask) :
1568 LocMsg(), mpAdapter(adapter),
1569 mNumberOfCerts(numberOfCerts), mSlotBitMask(slotBitMask),
1570 mpData(new DerEncodedCertificate[mNumberOfCerts])
1571 {
1572 for (int i=0; i < mNumberOfCerts; i++) {
1573 mpData[i].data = new u_char[pData[i].length];
1574 if (mpData[i].data) {
1575 memcpy(mpData[i].data, (void*)pData[i].data, pData[i].length);
1576 mpData[i].length = pData[i].length;
1577 } else {
1578 LOC_LOGE("malloc failed for cert#%d", i);
1579 break;
1580 }
1581 }
1582 locallog();
1583 }
~LocEngInstallAGpsCertLocEngInstallAGpsCert1584 inline ~LocEngInstallAGpsCert()
1585 {
1586 for (int i=0; i < mNumberOfCerts; i++) {
1587 if (mpData[i].data) {
1588 delete[] mpData[i].data;
1589 }
1590 }
1591 delete[] mpData;
1592 }
procLocEngInstallAGpsCert1593 inline virtual void proc() const {
1594 mpAdapter->installAGpsCert(mpData, mNumberOfCerts, mSlotBitMask);
1595 }
locallogLocEngInstallAGpsCert1596 inline void locallog() const {
1597 LOC_LOGV("LocEngInstallAGpsCert - certs=%u mask=%u",
1598 mNumberOfCerts, mSlotBitMask);
1599 }
logLocEngInstallAGpsCert1600 inline virtual void log() const {
1601 locallog();
1602 }
1603 };
1604
1605 struct LocEngUpdateRegistrationMask : public LocMsg {
1606 loc_eng_data_s_type* mLocEng;
1607 LOC_API_ADAPTER_EVENT_MASK_T mMask;
1608 loc_registration_mask_status mIsEnabled;
LocEngUpdateRegistrationMaskLocEngUpdateRegistrationMask1609 inline LocEngUpdateRegistrationMask(loc_eng_data_s_type* locEng,
1610 LOC_API_ADAPTER_EVENT_MASK_T mask,
1611 loc_registration_mask_status isEnabled) :
1612 LocMsg(), mLocEng(locEng), mMask(mask), mIsEnabled(isEnabled) {
1613 locallog();
1614 }
procLocEngUpdateRegistrationMask1615 inline virtual void proc() const {
1616 loc_eng_data_s_type *locEng = (loc_eng_data_s_type *)mLocEng;
1617 locEng->adapter->updateRegistrationMask(mMask,
1618 mIsEnabled);
1619 }
locallogLocEngUpdateRegistrationMask1620 void locallog() const {
1621 LOC_LOGV("LocEngUpdateRegistrationMask\n");
1622 }
logLocEngUpdateRegistrationMask1623 virtual void log() const {
1624 locallog();
1625 }
1626 };
1627
1628 struct LocEngGnssConstellationConfig : public LocMsg {
1629 LocEngAdapter* mAdapter;
LocEngGnssConstellationConfigLocEngGnssConstellationConfig1630 inline LocEngGnssConstellationConfig(LocEngAdapter* adapter) :
1631 LocMsg(), mAdapter(adapter) {
1632 locallog();
1633 }
procLocEngGnssConstellationConfig1634 inline virtual void proc() const {
1635 mAdapter->mGnssInfo.size = sizeof(GnssSystemInfo);
1636 if (mAdapter->gnssConstellationConfig()) {
1637 LOC_LOGV("Modem supports GNSS measurements\n");
1638 gps_conf.CAPABILITIES |= GPS_CAPABILITY_MEASUREMENTS;
1639 mAdapter->mGnssInfo.year_of_hw = 2016;
1640 } else {
1641 mAdapter->mGnssInfo.year_of_hw = 2015;
1642 LOC_LOGV("Modem does not support GNSS measurements\n");
1643 }
1644 }
locallogLocEngGnssConstellationConfig1645 void locallog() const {
1646 LOC_LOGV("LocEngGnssConstellationConfig\n");
1647 }
logLocEngGnssConstellationConfig1648 virtual void log() const {
1649 locallog();
1650 }
1651 };
1652
1653 // case LOC_ENG_MSG_REPORT_GNSS_MEASUREMENT:
LocEngReportGnssMeasurement(void * locEng,GnssData & gnssData)1654 LocEngReportGnssMeasurement::LocEngReportGnssMeasurement(void* locEng,
1655 GnssData &gnssData) :
1656 LocMsg(), mLocEng(locEng), mGnssData(gnssData)
1657 {
1658 locallog();
1659 }
proc() const1660 void LocEngReportGnssMeasurement::proc() const {
1661 loc_eng_data_s_type* locEng = (loc_eng_data_s_type*) mLocEng;
1662 if (locEng->mute_session_state != LOC_MUTE_SESS_IN_SESSION)
1663 {
1664 if (locEng->gnss_measurement_cb != NULL) {
1665 LOC_LOGV("Calling gnss_measurement_cb");
1666 locEng->gnss_measurement_cb((GnssData*)&(mGnssData));
1667 }
1668 }
1669 }
locallog() const1670 void LocEngReportGnssMeasurement::locallog() const {
1671 IF_LOC_LOGV {
1672 LOC_LOGV("%s:%d]: Received in GPS HAL."
1673 "GNSS Measurements count: %d \n",
1674 __func__, __LINE__, mGnssData.measurement_count);
1675 for (int i =0; i< mGnssData.measurement_count && i < GNSS_MAX_SVS; i++) {
1676 LOC_LOGV(" GNSS measurement data in GPS HAL: \n"
1677 " GPS_HAL => Measurement ID | svid | time_offset_ns | state |"
1678 " c_n0_dbhz | pseudorange_rate_mps |"
1679 " pseudorange_rate_uncertainty_mps |"
1680 " accumulated_delta_range_state | flags \n"
1681 " GPS_HAL => %d | %d | %f | %d | %f | %f | %f | %d | %d \n",
1682 i,
1683 mGnssData.measurements[i].svid,
1684 mGnssData.measurements[i].time_offset_ns,
1685 mGnssData.measurements[i].state,
1686 mGnssData.measurements[i].c_n0_dbhz,
1687 mGnssData.measurements[i].pseudorange_rate_mps,
1688 mGnssData.measurements[i].pseudorange_rate_uncertainty_mps,
1689 mGnssData.measurements[i].accumulated_delta_range_state,
1690 mGnssData.measurements[i].flags);
1691 }
1692 LOC_LOGV(" GPS_HAL => Clocks Info: \n"
1693 " time_ns | full_bias_ns | bias_ns | bias_uncertainty_ns | "
1694 " drift_nsps | drift_uncertainty_nsps | hw_clock_discontinuity_count | flags"
1695 " GPS_HAL => Clocks Info: %lld | %lld | %g | %g | %g | %g | %d | 0x%04x\n",
1696 mGnssData.clock.time_ns,
1697 mGnssData.clock.full_bias_ns,
1698 mGnssData.clock.bias_ns,
1699 mGnssData.clock.bias_uncertainty_ns,
1700 mGnssData.clock.drift_nsps,
1701 mGnssData.clock.drift_uncertainty_nsps,
1702 mGnssData.clock.hw_clock_discontinuity_count,
1703 mGnssData.clock.flags);
1704 }
1705 }
log() const1706 inline void LocEngReportGnssMeasurement::log() const {
1707 locallog();
1708 }
1709
1710 /*********************************************************************
1711 * Initialization checking macros
1712 *********************************************************************/
1713 #define STATE_CHECK(ctx, x, ret) \
1714 if (!(ctx)) \
1715 { \
1716 /* Not intialized, abort */\
1717 LOC_LOGE("%s: log_eng state error: %s", __func__, x); \
1718 EXIT_LOG(%s, x); \
1719 ret; \
1720 }
1721 #define INIT_CHECK(ctx, ret) STATE_CHECK(ctx, "instance not initialized", ret)
1722
1723 /*===========================================================================
1724 FUNCTION loc_eng_init
1725
1726 DESCRIPTION
1727 Initialize the location engine, this include setting up global datas
1728 and registers location engien with loc api service.
1729
1730 DEPENDENCIES
1731 None
1732
1733 RETURN VALUE
1734 0: success
1735
1736 SIDE EFFECTS
1737 N/A
1738
1739 ===========================================================================*/
loc_eng_init(loc_eng_data_s_type & loc_eng_data,LocCallbacks * callbacks,LOC_API_ADAPTER_EVENT_MASK_T event,ContextBase * context)1740 int loc_eng_init(loc_eng_data_s_type &loc_eng_data, LocCallbacks* callbacks,
1741 LOC_API_ADAPTER_EVENT_MASK_T event, ContextBase* context)
1742
1743 {
1744 int ret_val = 0;
1745
1746 ENTRY_LOG_CALLFLOW();
1747 if (NULL == callbacks || 0 == event) {
1748 LOC_LOGE("loc_eng_init: bad parameters cb %p eMask %d", callbacks, event);
1749 ret_val = -1;
1750 EXIT_LOG(%d, ret_val);
1751 return ret_val;
1752 }
1753
1754 STATE_CHECK((NULL == loc_eng_data.adapter),
1755 "instance already initialized", return 0);
1756
1757 memset(&loc_eng_data, 0, sizeof (loc_eng_data));
1758
1759 // Save callbacks
1760 loc_eng_data.location_cb = callbacks->location_cb;
1761 loc_eng_data.sv_status_cb = callbacks->sv_status_cb;
1762 loc_eng_data.status_cb = callbacks->status_cb;
1763 loc_eng_data.nmea_cb = callbacks->nmea_cb;
1764 loc_eng_data.set_capabilities_cb = callbacks->set_capabilities_cb;
1765 loc_eng_data.acquire_wakelock_cb = callbacks->acquire_wakelock_cb;
1766 loc_eng_data.release_wakelock_cb = callbacks->release_wakelock_cb;
1767 loc_eng_data.request_utc_time_cb = callbacks->request_utc_time_cb;
1768 loc_eng_data.set_system_info_cb = callbacks->set_system_info_cb;
1769 loc_eng_data.gnss_sv_status_cb = callbacks->gnss_sv_status_cb;
1770 loc_eng_data.location_ext_parser = callbacks->location_ext_parser ?
1771 callbacks->location_ext_parser : noProc;
1772 loc_eng_data.sv_ext_parser = callbacks->sv_ext_parser ?
1773 callbacks->sv_ext_parser : noProc;
1774 loc_eng_data.intermediateFix = gps_conf.INTERMEDIATE_POS;
1775 // initial states taken care of by the memset above
1776 // loc_eng_data.engine_status -- GPS_STATUS_NONE;
1777 // loc_eng_data.fix_session_status -- GPS_STATUS_NONE;
1778 // loc_eng_data.mute_session_state -- LOC_MUTE_SESS_NONE;
1779
1780 if ((event & LOC_API_ADAPTER_BIT_NMEA_1HZ_REPORT) && (gps_conf.NMEA_PROVIDER == NMEA_PROVIDER_AP))
1781 {
1782 event = event ^ LOC_API_ADAPTER_BIT_NMEA_1HZ_REPORT; // unregister for modem NMEA report
1783 loc_eng_data.generateNmea = true;
1784 }
1785 else
1786 {
1787 loc_eng_data.generateNmea = false;
1788 }
1789
1790 loc_eng_data.adapter =
1791 new LocEngAdapter(event, &loc_eng_data, context,
1792 (LocThread::tCreate)callbacks->create_thread_cb);
1793
1794 loc_eng_data.adapter->mGnssInfo.size = sizeof(GnssSystemInfo);
1795 loc_eng_data.adapter->mGnssInfo.year_of_hw = 2015;
1796 LOC_LOGD("loc_eng_init created client, id = %p\n",
1797 loc_eng_data.adapter);
1798 loc_eng_data.adapter->sendMsg(new LocEngInit(&loc_eng_data));
1799
1800 EXIT_LOG(%d, ret_val);
1801 return ret_val;
1802 }
1803
loc_eng_reinit(loc_eng_data_s_type & loc_eng_data)1804 static int loc_eng_reinit(loc_eng_data_s_type &loc_eng_data)
1805 {
1806 ENTRY_LOG();
1807 int ret_val = LOC_API_ADAPTER_ERR_SUCCESS;
1808 LocEngAdapter* adapter = loc_eng_data.adapter;
1809
1810 adapter->sendMsg(new LocEngGnssConstellationConfig(adapter));
1811 adapter->sendMsg(new LocEngSuplVer(adapter, gps_conf.SUPL_VER));
1812 adapter->sendMsg(new LocEngLppConfig(adapter, gps_conf.LPP_PROFILE));
1813 adapter->sendMsg(new LocEngSensorControlConfig(adapter, sap_conf.SENSOR_USAGE,
1814 sap_conf.SENSOR_PROVIDER));
1815 adapter->sendMsg(new LocEngAGlonassProtocol(adapter, gps_conf.A_GLONASS_POS_PROTOCOL_SELECT));
1816
1817 /* Make sure at least one of the sensor property is specified by the user in the gps.conf file. */
1818 if( sap_conf.GYRO_BIAS_RANDOM_WALK_VALID ||
1819 sap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY_VALID ||
1820 sap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY_VALID ||
1821 sap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY_VALID ||
1822 sap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY_VALID ) {
1823 adapter->sendMsg(new LocEngSensorProperties(adapter,
1824 sap_conf.GYRO_BIAS_RANDOM_WALK_VALID,
1825 sap_conf.GYRO_BIAS_RANDOM_WALK,
1826 sap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY_VALID,
1827 sap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY,
1828 sap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY_VALID,
1829 sap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY,
1830 sap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY_VALID,
1831 sap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY,
1832 sap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY_VALID,
1833 sap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY));
1834 }
1835
1836 adapter->sendMsg(new LocEngSensorPerfControlConfig(adapter,
1837 sap_conf.SENSOR_CONTROL_MODE,
1838 sap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH,
1839 sap_conf.SENSOR_ACCEL_BATCHES_PER_SEC,
1840 sap_conf.SENSOR_GYRO_SAMPLES_PER_BATCH,
1841 sap_conf.SENSOR_GYRO_BATCHES_PER_SEC,
1842 sap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH_HIGH,
1843 sap_conf.SENSOR_ACCEL_BATCHES_PER_SEC_HIGH,
1844 sap_conf.SENSOR_GYRO_SAMPLES_PER_BATCH_HIGH,
1845 sap_conf.SENSOR_GYRO_BATCHES_PER_SEC_HIGH,
1846 sap_conf.SENSOR_ALGORITHM_CONFIG_MASK));
1847
1848 adapter->sendMsg(new LocEngEnableData(adapter, NULL, 0, (agpsStatus ? 1:0)));
1849
1850 loc_eng_xtra_version_check(loc_eng_data, gps_conf.XTRA_VERSION_CHECK);
1851
1852 LOC_LOGD("loc_eng_reinit reinit() successful");
1853 EXIT_LOG(%d, ret_val);
1854 return ret_val;
1855 }
1856
1857 /*===========================================================================
1858 FUNCTION loc_eng_cleanup
1859
1860 DESCRIPTION
1861 Cleans location engine. The location client handle will be released.
1862
1863 DEPENDENCIES
1864 None
1865
1866 RETURN VALUE
1867 None
1868
1869 SIDE EFFECTS
1870 N/A
1871
1872 ===========================================================================*/
loc_eng_cleanup(loc_eng_data_s_type & loc_eng_data)1873 void loc_eng_cleanup(loc_eng_data_s_type &loc_eng_data)
1874 {
1875 ENTRY_LOG_CALLFLOW();
1876 INIT_CHECK(loc_eng_data.adapter, return);
1877
1878 // XTRA has no state, so we are fine with it.
1879
1880 // we need to check and clear NI
1881 #if 0
1882 // we need to check and clear ATL
1883 if (NULL != loc_eng_data.agnss_nif) {
1884 delete loc_eng_data.agnss_nif;
1885 loc_eng_data.agnss_nif = NULL;
1886 }
1887 if (NULL != loc_eng_data.internet_nif) {
1888 delete loc_eng_data.internet_nif;
1889 loc_eng_data.internet_nif = NULL;
1890 }
1891 #endif
1892 if (loc_eng_data.adapter->isInSession())
1893 {
1894 LOC_LOGD("loc_eng_cleanup: fix not stopped. stop it now.");
1895 loc_eng_stop(loc_eng_data);
1896 }
1897
1898 #if 0 // can't afford to actually clean up, for many reason.
1899
1900 LOC_LOGD("loc_eng_init: client opened. close it now.");
1901 delete loc_eng_data.adapter;
1902 loc_eng_data.adapter = NULL;
1903
1904 loc_eng_dmn_conn_loc_api_server_unblock();
1905 loc_eng_dmn_conn_loc_api_server_join();
1906
1907 #endif
1908
1909 EXIT_LOG(%s, VOID_RET);
1910 }
1911
1912
1913 /*===========================================================================
1914 FUNCTION loc_eng_start
1915
1916 DESCRIPTION
1917 Starts the tracking session
1918
1919 DEPENDENCIES
1920 None
1921
1922 RETURN VALUE
1923 0: success
1924
1925 SIDE EFFECTS
1926 N/A
1927
1928 ===========================================================================*/
loc_eng_start(loc_eng_data_s_type & loc_eng_data)1929 int loc_eng_start(loc_eng_data_s_type &loc_eng_data)
1930 {
1931 ENTRY_LOG_CALLFLOW();
1932 INIT_CHECK(loc_eng_data.adapter, return -1);
1933
1934 if(! loc_eng_data.adapter->getUlpProxy()->sendStartFix())
1935 {
1936 loc_eng_data.adapter->sendMsg(new LocEngStartFix(loc_eng_data.adapter));
1937 }
1938
1939 EXIT_LOG(%d, 0);
1940 return 0;
1941 }
1942
loc_eng_start_handler(loc_eng_data_s_type & loc_eng_data)1943 static int loc_eng_start_handler(loc_eng_data_s_type &loc_eng_data)
1944 {
1945 ENTRY_LOG();
1946 int ret_val = LOC_API_ADAPTER_ERR_SUCCESS;
1947
1948 if (!loc_eng_data.adapter->isInSession()) {
1949 ret_val = loc_eng_data.adapter->startFix();
1950
1951 if (ret_val == LOC_API_ADAPTER_ERR_SUCCESS ||
1952 ret_val == LOC_API_ADAPTER_ERR_ENGINE_DOWN ||
1953 ret_val == LOC_API_ADAPTER_ERR_PHONE_OFFLINE ||
1954 ret_val == LOC_API_ADAPTER_ERR_INTERNAL)
1955 {
1956 loc_eng_data.adapter->setInSession(TRUE);
1957 }
1958 }
1959
1960 EXIT_LOG(%d, ret_val);
1961 return ret_val;
1962 }
1963
1964 /*===========================================================================
1965 FUNCTION loc_eng_stop_wrapper
1966
1967 DESCRIPTION
1968 Stops the tracking session
1969
1970 DEPENDENCIES
1971 None
1972
1973 RETURN VALUE
1974 0: success
1975
1976 SIDE EFFECTS
1977 N/A
1978
1979 ===========================================================================*/
loc_eng_stop(loc_eng_data_s_type & loc_eng_data)1980 int loc_eng_stop(loc_eng_data_s_type &loc_eng_data)
1981 {
1982 ENTRY_LOG_CALLFLOW();
1983 INIT_CHECK(loc_eng_data.adapter, return -1);
1984
1985 if(! loc_eng_data.adapter->getUlpProxy()->sendStopFix())
1986 {
1987 loc_eng_data.adapter->sendMsg(new LocEngStopFix(loc_eng_data.adapter));
1988 }
1989
1990 EXIT_LOG(%d, 0);
1991 return 0;
1992 }
1993
loc_eng_stop_handler(loc_eng_data_s_type & loc_eng_data)1994 static int loc_eng_stop_handler(loc_eng_data_s_type &loc_eng_data)
1995 {
1996 ENTRY_LOG();
1997 int ret_val = LOC_API_ADAPTER_ERR_SUCCESS;
1998
1999 if (loc_eng_data.adapter->isInSession()) {
2000
2001 ret_val = loc_eng_data.adapter->stopFix();
2002 loc_eng_data.adapter->setInSession(FALSE);
2003 }
2004
2005 EXIT_LOG(%d, ret_val);
2006 return ret_val;
2007 }
2008
2009 /*===========================================================================
2010 FUNCTION loc_eng_mute_one_session
2011
2012 DESCRIPTION
2013 Mutes one session
2014
2015 DEPENDENCIES
2016 None
2017
2018 RETURN VALUE
2019 0: Success
2020
2021 SIDE EFFECTS
2022 N/A
2023
2024 ===========================================================================*/
loc_eng_mute_one_session(loc_eng_data_s_type & loc_eng_data)2025 void loc_eng_mute_one_session(loc_eng_data_s_type &loc_eng_data)
2026 {
2027 ENTRY_LOG();
2028 loc_eng_data.mute_session_state = LOC_MUTE_SESS_WAIT;
2029 EXIT_LOG(%s, VOID_RET);
2030 }
2031
2032 /*===========================================================================
2033 FUNCTION loc_eng_set_position_mode
2034
2035 DESCRIPTION
2036 Sets the mode and fix frequency for the tracking session.
2037
2038 DEPENDENCIES
2039 None
2040
2041 RETURN VALUE
2042 0: success
2043
2044 SIDE EFFECTS
2045 N/A
2046
2047 ===========================================================================*/
loc_eng_set_position_mode(loc_eng_data_s_type & loc_eng_data,LocPosMode & params)2048 int loc_eng_set_position_mode(loc_eng_data_s_type &loc_eng_data,
2049 LocPosMode ¶ms)
2050 {
2051 ENTRY_LOG_CALLFLOW();
2052 INIT_CHECK(loc_eng_data.adapter, return -1);
2053
2054 // The position mode for AUTO/GSS/QCA1530 can only be standalone
2055 if (!(gps_conf.CAPABILITIES & GPS_CAPABILITY_MSB) &&
2056 !(gps_conf.CAPABILITIES & GPS_CAPABILITY_MSA) &&
2057 (params.mode != LOC_POSITION_MODE_STANDALONE)) {
2058 params.mode = LOC_POSITION_MODE_STANDALONE;
2059 LOC_LOGD("Position mode changed to standalone for target with AUTO/GSS/qca1530.");
2060 }
2061
2062 if(! loc_eng_data.adapter->getUlpProxy()->sendFixMode(params))
2063 {
2064 LocEngAdapter* adapter = loc_eng_data.adapter;
2065 adapter->sendMsg(new LocEngPositionMode(adapter, params));
2066 }
2067
2068 EXIT_LOG(%d, 0);
2069 return 0;
2070 }
2071
2072 /*===========================================================================
2073 FUNCTION loc_eng_inject_time
2074
2075 DESCRIPTION
2076 This is used by Java native function to do time injection.
2077
2078 DEPENDENCIES
2079 None
2080
2081 RETURN VALUE
2082 0
2083
2084 SIDE EFFECTS
2085 N/A
2086
2087 ===========================================================================*/
loc_eng_inject_time(loc_eng_data_s_type & loc_eng_data,GpsUtcTime time,int64_t timeReference,int uncertainty)2088 int loc_eng_inject_time(loc_eng_data_s_type &loc_eng_data, GpsUtcTime time,
2089 int64_t timeReference, int uncertainty)
2090 {
2091 ENTRY_LOG_CALLFLOW();
2092 INIT_CHECK(loc_eng_data.adapter, return -1);
2093 LocEngAdapter* adapter = loc_eng_data.adapter;
2094
2095 adapter->sendMsg(new LocEngSetTime(adapter, time, timeReference,
2096 uncertainty));
2097
2098 EXIT_LOG(%d, 0);
2099 return 0;
2100 }
2101
2102
2103 /*===========================================================================
2104 FUNCTION loc_eng_inject_location
2105
2106 DESCRIPTION
2107 This is used by Java native function to do location injection.
2108
2109 DEPENDENCIES
2110 None
2111
2112 RETURN VALUE
2113 0 : Successful
2114 error code : Failure
2115
2116 SIDE EFFECTS
2117 N/A
2118 ===========================================================================*/
loc_eng_inject_location(loc_eng_data_s_type & loc_eng_data,double latitude,double longitude,float accuracy)2119 int loc_eng_inject_location(loc_eng_data_s_type &loc_eng_data, double latitude,
2120 double longitude, float accuracy)
2121 {
2122 ENTRY_LOG_CALLFLOW();
2123 INIT_CHECK(loc_eng_data.adapter, return -1);
2124 LocEngAdapter* adapter = loc_eng_data.adapter;
2125 if(adapter->mSupportsPositionInjection)
2126 {
2127 adapter->sendMsg(new LocEngInjectLocation(adapter, latitude, longitude,
2128 accuracy));
2129 }
2130
2131 EXIT_LOG(%d, 0);
2132 return 0;
2133 }
2134
2135
2136 /*===========================================================================
2137 FUNCTION loc_eng_delete_aiding_data
2138
2139 DESCRIPTION
2140 This is used by Java native function to delete the aiding data. The function
2141 updates the global variable for the aiding data to be deleted. If the GPS
2142 engine is off, the aiding data will be deleted. Otherwise, the actual action
2143 will happen when gps engine is turned off.
2144
2145 DEPENDENCIES
2146 Assumes the aiding data type specified in GpsAidingData matches with
2147 LOC API specification.
2148
2149 RETURN VALUE
2150 None
2151
2152 SIDE EFFECTS
2153 N/A
2154
2155 ===========================================================================*/
loc_eng_delete_aiding_data(loc_eng_data_s_type & loc_eng_data,GpsAidingData f)2156 void loc_eng_delete_aiding_data(loc_eng_data_s_type &loc_eng_data, GpsAidingData f)
2157 {
2158 ENTRY_LOG_CALLFLOW();
2159 INIT_CHECK(loc_eng_data.adapter, return);
2160
2161 loc_eng_data.adapter->sendMsg(new LocEngDelAidData(&loc_eng_data, f));
2162
2163 EXIT_LOG(%s, VOID_RET);
2164 }
2165
2166 /*===========================================================================
2167
2168 FUNCTION loc_inform_gps_state
2169
2170 DESCRIPTION
2171 Informs the GPS Provider about the GPS status
2172
2173 DEPENDENCIES
2174 None
2175
2176 RETURN VALUE
2177 None
2178
2179 SIDE EFFECTS
2180 N/A
2181
2182 ===========================================================================*/
loc_inform_gps_status(loc_eng_data_s_type & loc_eng_data,GpsStatusValue status)2183 static void loc_inform_gps_status(loc_eng_data_s_type &loc_eng_data, GpsStatusValue status)
2184 {
2185 ENTRY_LOG();
2186
2187 if (loc_eng_data.status_cb)
2188 {
2189 GpsStatus gs = { sizeof(gs),status };
2190 CALLBACK_LOG_CALLFLOW("status_cb", %s,
2191 loc_get_gps_status_name(gs.status));
2192 loc_eng_data.status_cb(&gs);
2193 }
2194
2195 EXIT_LOG(%s, VOID_RET);
2196 }
2197
loc_eng_get_zpp_handler(loc_eng_data_s_type & loc_eng_data)2198 static int loc_eng_get_zpp_handler(loc_eng_data_s_type &loc_eng_data)
2199 {
2200 ENTRY_LOG();
2201 int ret_val = LOC_API_ADAPTER_ERR_SUCCESS;
2202 UlpLocation location;
2203 LocPosTechMask tech_mask = LOC_POS_TECH_MASK_DEFAULT;
2204 GpsLocationExtended locationExtended;
2205 memset(&locationExtended, 0, sizeof (GpsLocationExtended));
2206 locationExtended.size = sizeof(locationExtended);
2207
2208 ret_val = loc_eng_data.adapter->getZpp(location.gpsLocation, tech_mask);
2209 //Mark the location source as from ZPP
2210 location.gpsLocation.flags |= LOCATION_HAS_SOURCE_INFO;
2211 location.position_source = ULP_LOCATION_IS_FROM_ZPP;
2212
2213 loc_eng_data.adapter->getUlpProxy()->reportPosition(location,
2214 locationExtended,
2215 NULL,
2216 LOC_SESS_SUCCESS,
2217 tech_mask);
2218
2219 EXIT_LOG(%d, ret_val);
2220 return ret_val;
2221 }
2222
2223 /*
2224 Callback function passed to Data Services State Machine
2225 This becomes part of the state machine's servicer and
2226 is used to send requests to the data services client
2227 */
dataCallCb(void * cb_data)2228 static int dataCallCb(void *cb_data)
2229 {
2230 LOC_LOGD("Enter dataCallCb\n");
2231 int ret=0;
2232 if(cb_data != NULL) {
2233 dsCbData *cbData = (dsCbData *)cb_data;
2234 LocEngAdapter *locAdapter = (LocEngAdapter *)cbData->mAdapter;
2235 if(cbData->action == GPS_REQUEST_AGPS_DATA_CONN) {
2236 LOC_LOGD("dataCallCb GPS_REQUEST_AGPS_DATA_CONN\n");
2237 ret = locAdapter->openAndStartDataCall();
2238 }
2239 else if(cbData->action == GPS_RELEASE_AGPS_DATA_CONN) {
2240 LOC_LOGD("dataCallCb GPS_RELEASE_AGPS_DATA_CONN\n");
2241 locAdapter->stopDataCall();
2242 }
2243 }
2244 else {
2245 LOC_LOGE("NULL argument received. Failing.\n");
2246 ret = -1;
2247 goto err;
2248 }
2249
2250 err:
2251 LOC_LOGD("Exit dataCallCb ret = %d\n", ret);
2252 return ret;
2253 }
2254
2255 /*===========================================================================
2256 FUNCTION loc_eng_agps_reinit
2257
2258 DESCRIPTION
2259 2nd half of loc_eng_agps_init(), singled out for modem restart to use.
2260
2261 DEPENDENCIES
2262 NONE
2263
2264 RETURN VALUE
2265 0
2266
2267 SIDE EFFECTS
2268 N/A
2269
2270 ===========================================================================*/
loc_eng_agps_reinit(loc_eng_data_s_type & loc_eng_data)2271 static void loc_eng_agps_reinit(loc_eng_data_s_type &loc_eng_data)
2272 {
2273 ENTRY_LOG();
2274
2275 // Set server addresses which came before init
2276 if (loc_eng_data.supl_host_set)
2277 {
2278 loc_eng_set_server(loc_eng_data, LOC_AGPS_SUPL_SERVER,
2279 loc_eng_data.supl_host_buf,
2280 loc_eng_data.supl_port_buf);
2281 }
2282
2283 if (loc_eng_data.c2k_host_set)
2284 {
2285 loc_eng_set_server(loc_eng_data, LOC_AGPS_CDMA_PDE_SERVER,
2286 loc_eng_data.c2k_host_buf,
2287 loc_eng_data.c2k_port_buf);
2288 }
2289 EXIT_LOG(%s, VOID_RET);
2290 }
2291 /*===========================================================================
2292 FUNCTION loc_eng_agps_init
2293
2294 DESCRIPTION
2295 Initialize the AGps interface.
2296
2297 DEPENDENCIES
2298 NONE
2299
2300 RETURN VALUE
2301 0
2302
2303 SIDE EFFECTS
2304 N/A
2305
2306 ===========================================================================*/
loc_eng_agps_init(loc_eng_data_s_type & loc_eng_data,AGpsExtCallbacks * callbacks)2307 void loc_eng_agps_init(loc_eng_data_s_type &loc_eng_data, AGpsExtCallbacks* callbacks)
2308 {
2309 ENTRY_LOG_CALLFLOW();
2310 INIT_CHECK(loc_eng_data.adapter, return);
2311 STATE_CHECK((NULL == loc_eng_data.agps_status_cb),
2312 "agps instance already initialized",
2313 return);
2314 if (callbacks == NULL) {
2315 LOC_LOGE("loc_eng_agps_init: bad parameters cb %p", callbacks);
2316 EXIT_LOG(%s, VOID_RET);
2317 return;
2318 }
2319 LocEngAdapter* adapter = loc_eng_data.adapter;
2320 loc_eng_data.agps_status_cb = callbacks->status_cb;
2321
2322 loc_eng_data.internet_nif = new AgpsStateMachine(servicerTypeAgps,
2323 (void *)loc_eng_data.agps_status_cb,
2324 AGPS_TYPE_WWAN_ANY,
2325 false);
2326 loc_eng_data.wifi_nif = new AgpsStateMachine(servicerTypeAgps,
2327 (void *)loc_eng_data.agps_status_cb,
2328 AGPS_TYPE_WIFI,
2329 true);
2330
2331 if ((gps_conf.CAPABILITIES & GPS_CAPABILITY_MSA) ||
2332 (gps_conf.CAPABILITIES & GPS_CAPABILITY_MSB)) {
2333 loc_eng_data.agnss_nif = new AgpsStateMachine(servicerTypeAgps,
2334 (void *)loc_eng_data.agps_status_cb,
2335 AGPS_TYPE_SUPL,
2336 false);
2337
2338 if (adapter->mSupportsAgpsRequests) {
2339 if(gps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL) {
2340 loc_eng_data.adapter->sendMsg(new LocEngDataClientInit(&loc_eng_data));
2341 }
2342 loc_eng_dmn_conn_loc_api_server_launch(callbacks->create_thread_cb,
2343 NULL, NULL, &loc_eng_data);
2344 }
2345 loc_eng_agps_reinit(loc_eng_data);
2346 }
2347
2348 EXIT_LOG(%s, VOID_RET);
2349 }
2350
deleteAidingData(loc_eng_data_s_type & logEng)2351 static void deleteAidingData(loc_eng_data_s_type &logEng) {
2352 if (logEng.engine_status != GPS_STATUS_ENGINE_ON &&
2353 logEng.aiding_data_for_deletion != 0) {
2354 logEng.adapter->deleteAidingData(logEng.aiding_data_for_deletion);
2355 logEng.aiding_data_for_deletion = 0;
2356 }
2357 }
2358
2359 static AgpsStateMachine*
getAgpsStateMachine(loc_eng_data_s_type & locEng,AGpsExtType agpsType)2360 getAgpsStateMachine(loc_eng_data_s_type &locEng, AGpsExtType agpsType) {
2361 AgpsStateMachine* stateMachine;
2362 switch (agpsType) {
2363 case AGPS_TYPE_WIFI: {
2364 stateMachine = locEng.wifi_nif;
2365 break;
2366 }
2367 case AGPS_TYPE_INVALID:
2368 case AGPS_TYPE_SUPL: {
2369 stateMachine = locEng.agnss_nif;
2370 break;
2371 }
2372 case AGPS_TYPE_SUPL_ES: {
2373 locEng.ds_nif ?
2374 stateMachine = locEng.ds_nif:
2375 stateMachine = locEng.agnss_nif;
2376 break;
2377 }
2378 default:
2379 stateMachine = locEng.internet_nif;
2380 }
2381 return stateMachine;
2382 }
2383
2384 /*===========================================================================
2385 FUNCTION loc_eng_agps_open
2386
2387 DESCRIPTION
2388 This function is called when on-demand data connection opening is successful.
2389 It should inform engine about the data open result.
2390
2391 DEPENDENCIES
2392 NONE
2393
2394 RETURN VALUE
2395 0
2396
2397 SIDE EFFECTS
2398 N/A
2399
2400 ===========================================================================*/
loc_eng_agps_open(loc_eng_data_s_type & loc_eng_data,AGpsExtType agpsType,const char * apn,AGpsBearerType bearerType)2401 int loc_eng_agps_open(loc_eng_data_s_type &loc_eng_data, AGpsExtType agpsType,
2402 const char* apn, AGpsBearerType bearerType)
2403 {
2404 ENTRY_LOG_CALLFLOW();
2405 INIT_CHECK(loc_eng_data.adapter && loc_eng_data.agps_status_cb,
2406 return -1);
2407
2408 if (apn == NULL)
2409 {
2410 LOC_LOGE("APN Name NULL\n");
2411 return 0;
2412 }
2413
2414 LOC_LOGD("loc_eng_agps_open APN name = [%s]", apn);
2415
2416 int apn_len = smaller_of(strlen (apn), MAX_APN_LEN);
2417 AgpsStateMachine* sm = getAgpsStateMachine(loc_eng_data, agpsType);
2418
2419 loc_eng_data.adapter->sendMsg(
2420 new LocEngAtlOpenSuccess(sm, apn, apn_len, bearerType));
2421
2422 EXIT_LOG(%d, 0);
2423 return 0;
2424 }
2425
2426 /*===========================================================================
2427 FUNCTION loc_eng_agps_closed
2428
2429 DESCRIPTION
2430 This function is called when on-demand data connection closing is done.
2431 It should inform engine about the data close result.
2432
2433 DEPENDENCIES
2434 NONE
2435
2436 RETURN VALUE
2437 0
2438
2439 SIDE EFFECTS
2440 N/A
2441
2442 ===========================================================================*/
loc_eng_agps_closed(loc_eng_data_s_type & loc_eng_data,AGpsExtType agpsType)2443 int loc_eng_agps_closed(loc_eng_data_s_type &loc_eng_data, AGpsExtType agpsType)
2444 {
2445 ENTRY_LOG_CALLFLOW();
2446 INIT_CHECK(loc_eng_data.adapter && loc_eng_data.agps_status_cb,
2447 return -1);
2448
2449 AgpsStateMachine* sm = getAgpsStateMachine(loc_eng_data, agpsType);
2450 loc_eng_data.adapter->sendMsg(new LocEngAtlClosed(sm));
2451
2452 EXIT_LOG(%d, 0);
2453 return 0;
2454 }
2455
2456 /*===========================================================================
2457 FUNCTION loc_eng_agps_open_failed
2458
2459 DESCRIPTION
2460 This function is called when on-demand data connection opening has failed.
2461 It should inform engine about the data open result.
2462
2463 DEPENDENCIES
2464 NONE
2465
2466 RETURN VALUE
2467 0
2468
2469 SIDE EFFECTS
2470 N/A
2471
2472 ===========================================================================*/
loc_eng_agps_open_failed(loc_eng_data_s_type & loc_eng_data,AGpsExtType agpsType)2473 int loc_eng_agps_open_failed(loc_eng_data_s_type &loc_eng_data, AGpsExtType agpsType)
2474 {
2475 ENTRY_LOG_CALLFLOW();
2476 INIT_CHECK(loc_eng_data.adapter && loc_eng_data.agps_status_cb,
2477 return -1);
2478
2479 AgpsStateMachine* sm = getAgpsStateMachine(loc_eng_data, agpsType);
2480 loc_eng_data.adapter->sendMsg(new LocEngAtlOpenFailed(sm));
2481
2482 EXIT_LOG(%d, 0);
2483 return 0;
2484 }
2485
2486 /*===========================================================================
2487
2488 FUNCTION resolve_in_addr
2489
2490 DESCRIPTION
2491 Translates a hostname to in_addr struct
2492
2493 DEPENDENCIES
2494 n/a
2495
2496 RETURN VALUE
2497 TRUE if successful
2498
2499 SIDE EFFECTS
2500 n/a
2501
2502 ===========================================================================*/
resolve_in_addr(const char * host_addr,struct in_addr * in_addr_ptr)2503 static boolean resolve_in_addr(const char *host_addr, struct in_addr *in_addr_ptr)
2504 {
2505 ENTRY_LOG();
2506 boolean ret_val = TRUE;
2507
2508 struct hostent *hp;
2509 hp = gethostbyname(host_addr);
2510 if (hp != NULL) /* DNS OK */
2511 {
2512 memcpy(in_addr_ptr, hp->h_addr_list[0], hp->h_length);
2513 }
2514 else
2515 {
2516 /* Try IP representation */
2517 if (inet_aton(host_addr, in_addr_ptr) == 0)
2518 {
2519 /* IP not valid */
2520 LOC_LOGE("DNS query on '%s' failed\n", host_addr);
2521 ret_val = FALSE;
2522 }
2523 }
2524
2525 EXIT_LOG(%s, loc_logger_boolStr[ret_val!=0]);
2526 return ret_val;
2527 }
2528
2529 /*===========================================================================
2530 FUNCTION loc_eng_set_server
2531
2532 DESCRIPTION
2533 This is used to set the default AGPS server. Server address is obtained
2534 from gps.conf.
2535
2536 DEPENDENCIES
2537 NONE
2538
2539 RETURN VALUE
2540 0
2541
2542 SIDE EFFECTS
2543 N/A
2544
2545 ===========================================================================*/
loc_eng_set_server(loc_eng_data_s_type & loc_eng_data,LocServerType type,const char * hostname,int port)2546 static int loc_eng_set_server(loc_eng_data_s_type &loc_eng_data,
2547 LocServerType type, const char* hostname, int port)
2548 {
2549 ENTRY_LOG();
2550 int ret = 0;
2551 LocEngAdapter* adapter = loc_eng_data.adapter;
2552
2553 if (LOC_AGPS_SUPL_SERVER == type) {
2554 char url[MAX_URL_LEN];
2555 unsigned int len = 0;
2556 const char nohost[] = "NONE";
2557 if (hostname == NULL ||
2558 strncasecmp(nohost, hostname, sizeof(nohost)) == 0) {
2559 url[0] = NULL;
2560 } else {
2561 len = snprintf(url, sizeof(url), "%s:%u", hostname, (unsigned) port);
2562 }
2563
2564 if (sizeof(url) > len) {
2565 adapter->sendMsg(new LocEngSetServerUrl(adapter, url, len));
2566 }
2567 } else if (LOC_AGPS_CDMA_PDE_SERVER == type ||
2568 LOC_AGPS_CUSTOM_PDE_SERVER == type ||
2569 LOC_AGPS_MPC_SERVER == type) {
2570 struct in_addr addr;
2571 if (!resolve_in_addr(hostname, &addr))
2572 {
2573 LOC_LOGE("loc_eng_set_server, hostname %s cannot be resolved.\n", hostname);
2574 ret = -2;
2575 } else {
2576 unsigned int ip = htonl(addr.s_addr);
2577 adapter->sendMsg(new LocEngSetServerIpv4(adapter, ip, port, type));
2578 }
2579 } else {
2580 LOC_LOGE("loc_eng_set_server, type %d cannot be resolved.\n", type);
2581 }
2582
2583 EXIT_LOG(%d, ret);
2584 return ret;
2585 }
2586
2587 /*===========================================================================
2588 FUNCTION loc_eng_set_server_proxy
2589
2590 DESCRIPTION
2591 If loc_eng_set_server is called before loc_eng_init, it doesn't work. This
2592 proxy buffers server settings and calls loc_eng_set_server when the client is
2593 open.
2594
2595 DEPENDENCIES
2596 NONE
2597
2598 RETURN VALUE
2599 0
2600
2601 SIDE EFFECTS
2602 N/A
2603
2604 ===========================================================================*/
loc_eng_set_server_proxy(loc_eng_data_s_type & loc_eng_data,LocServerType type,const char * hostname,int port)2605 int loc_eng_set_server_proxy(loc_eng_data_s_type &loc_eng_data,
2606 LocServerType type,
2607 const char* hostname, int port)
2608 {
2609 ENTRY_LOG_CALLFLOW();
2610 int ret_val = 0;
2611
2612 LOC_LOGV("save the address, type: %d, hostname: %s, port: %d",
2613 (int) type, hostname, port);
2614 switch (type)
2615 {
2616 case LOC_AGPS_SUPL_SERVER:
2617 strlcpy(loc_eng_data.supl_host_buf, hostname,
2618 sizeof(loc_eng_data.supl_host_buf));
2619 loc_eng_data.supl_port_buf = port;
2620 loc_eng_data.supl_host_set = 1;
2621 break;
2622 case LOC_AGPS_CDMA_PDE_SERVER:
2623 strlcpy(loc_eng_data.c2k_host_buf, hostname,
2624 sizeof(loc_eng_data.c2k_host_buf));
2625 loc_eng_data.c2k_port_buf = port;
2626 loc_eng_data.c2k_host_set = 1;
2627 break;
2628 default:
2629 LOC_LOGE("loc_eng_set_server_proxy, unknown server type = %d", (int) type);
2630 }
2631
2632 if (NULL != loc_eng_data.adapter)
2633 {
2634 ret_val = loc_eng_set_server(loc_eng_data, type, hostname, port);
2635 }
2636
2637 EXIT_LOG(%d, ret_val);
2638 return ret_val;
2639 }
2640
2641 /*===========================================================================
2642 FUNCTION loc_eng_agps_ril_update_network_availability
2643
2644 DESCRIPTION
2645 Sets data call allow vs disallow flag to modem
2646 This is the only member of sLocEngAGpsRilInterface implemented.
2647
2648 DEPENDENCIES
2649 None
2650
2651 RETURN VALUE
2652 0: success
2653
2654 SIDE EFFECTS
2655 N/A
2656
2657 ===========================================================================*/
loc_eng_agps_ril_update_network_availability(loc_eng_data_s_type & loc_eng_data,int available,const char * apn)2658 void loc_eng_agps_ril_update_network_availability(loc_eng_data_s_type &loc_eng_data,
2659 int available, const char* apn)
2660 {
2661 ENTRY_LOG_CALLFLOW();
2662
2663 //This is to store the status of data availability over the network.
2664 //If GPS is not enabled, the INIT_CHECK will fail and the modem will
2665 //not be updated with the network's availability. Since the data status
2666 //can change before GPS is enabled the, storing the status will enable
2667 //us to inform the modem after GPS is enabled
2668 agpsStatus = available;
2669
2670 INIT_CHECK(loc_eng_data.adapter, return);
2671 if (apn != NULL)
2672 {
2673 LOC_LOGD("loc_eng_agps_ril_update_network_availability: APN Name = [%s]\n", apn);
2674 int apn_len = smaller_of(strlen (apn), MAX_APN_LEN);
2675 LocEngAdapter* adapter = loc_eng_data.adapter;
2676 adapter->sendMsg(new LocEngEnableData(adapter, apn, apn_len, available));
2677 }
2678 EXIT_LOG(%s, VOID_RET);
2679 }
2680
loc_eng_agps_install_certificates(loc_eng_data_s_type & loc_eng_data,const DerEncodedCertificate * certificates,size_t numberOfCerts)2681 int loc_eng_agps_install_certificates(loc_eng_data_s_type &loc_eng_data,
2682 const DerEncodedCertificate* certificates,
2683 size_t numberOfCerts)
2684 {
2685 ENTRY_LOG_CALLFLOW();
2686 int ret_val = AGPS_CERTIFICATE_OPERATION_SUCCESS;
2687
2688 uint32_t slotBitMask = gps_conf.AGPS_CERT_WRITABLE_MASK;
2689 uint32_t slotCount = 0;
2690 for (uint32_t slotBitMaskCounter=slotBitMask; slotBitMaskCounter; slotCount++) {
2691 slotBitMaskCounter &= slotBitMaskCounter - 1;
2692 }
2693 LOC_LOGD("SlotBitMask=%u SlotCount=%u NumberOfCerts=%u",
2694 slotBitMask, slotCount, numberOfCerts);
2695
2696 LocEngAdapter* adapter = loc_eng_data.adapter;
2697
2698 if (numberOfCerts == 0) {
2699 LOC_LOGE("No certs to install, since numberOfCerts is zero");
2700 ret_val = AGPS_CERTIFICATE_OPERATION_SUCCESS;
2701 } else if (!adapter) {
2702 LOC_LOGE("adapter is null!");
2703 ret_val = AGPS_CERTIFICATE_ERROR_GENERIC;
2704 } else if (slotCount < numberOfCerts) {
2705 LOC_LOGE("Not enough cert slots (%u) to install %u certs!",
2706 slotCount, numberOfCerts);
2707 ret_val = AGPS_CERTIFICATE_ERROR_TOO_MANY_CERTIFICATES;
2708 } else {
2709 for (int i=0; i < numberOfCerts; ++i)
2710 {
2711 if (certificates[i].length > AGPS_CERTIFICATE_MAX_LENGTH) {
2712 LOC_LOGE("cert#(%u) length of %u is too big! greater than %u",
2713 certificates[i].length, AGPS_CERTIFICATE_MAX_LENGTH);
2714 ret_val = AGPS_CERTIFICATE_ERROR_GENERIC;
2715 break;
2716 }
2717 }
2718
2719 if (ret_val == AGPS_CERTIFICATE_OPERATION_SUCCESS) {
2720 adapter->sendMsg(new LocEngInstallAGpsCert(adapter,
2721 certificates,
2722 numberOfCerts,
2723 slotBitMask));
2724 }
2725 }
2726
2727 EXIT_LOG(%d, ret_val);
2728 return ret_val;
2729 }
2730
loc_eng_configuration_update(loc_eng_data_s_type & loc_eng_data,const char * config_data,int32_t length)2731 void loc_eng_configuration_update (loc_eng_data_s_type &loc_eng_data,
2732 const char* config_data, int32_t length)
2733 {
2734 ENTRY_LOG_CALLFLOW();
2735
2736 if (config_data && length > 0) {
2737 loc_gps_cfg_s_type gps_conf_tmp = gps_conf;
2738 UTIL_UPDATE_CONF(config_data, length, gps_conf_table);
2739 LocEngAdapter* adapter = loc_eng_data.adapter;
2740
2741 // it is possible that HAL is not init'ed at this time
2742 if (adapter) {
2743 if (gps_conf_tmp.SUPL_VER != gps_conf.SUPL_VER) {
2744 adapter->sendMsg(new LocEngSuplVer(adapter, gps_conf.SUPL_VER));
2745 }
2746 if (gps_conf_tmp.LPP_PROFILE != gps_conf.LPP_PROFILE) {
2747 adapter->sendMsg(new LocEngLppConfig(adapter, gps_conf.LPP_PROFILE));
2748 }
2749 if (gps_conf_tmp.A_GLONASS_POS_PROTOCOL_SELECT != gps_conf.A_GLONASS_POS_PROTOCOL_SELECT) {
2750 adapter->sendMsg(new LocEngAGlonassProtocol(adapter,
2751 gps_conf.A_GLONASS_POS_PROTOCOL_SELECT));
2752 }
2753 if (gps_conf_tmp.SUPL_MODE != gps_conf.SUPL_MODE) {
2754 adapter->sendMsg(new LocEngSuplMode(adapter->getUlpProxy()));
2755 }
2756 }
2757
2758 gps_conf_tmp.SUPL_VER = gps_conf.SUPL_VER;
2759 gps_conf_tmp.LPP_PROFILE = gps_conf.LPP_PROFILE;
2760 gps_conf_tmp.A_GLONASS_POS_PROTOCOL_SELECT = gps_conf.A_GLONASS_POS_PROTOCOL_SELECT;
2761 gps_conf_tmp.GPS_LOCK = gps_conf.GPS_LOCK;
2762 gps_conf = gps_conf_tmp;
2763 }
2764
2765 EXIT_LOG(%s, VOID_RET);
2766 }
2767
2768 /*===========================================================================
2769 FUNCTION loc_eng_report_status
2770
2771 DESCRIPTION
2772 Reports GPS engine state to Java layer.
2773
2774 DEPENDENCIES
2775 N/A
2776
2777 RETURN VALUE
2778 N/A
2779
2780 SIDE EFFECTS
2781 N/A
2782
2783 ===========================================================================*/
loc_eng_report_status(loc_eng_data_s_type & loc_eng_data,GpsStatusValue status)2784 static void loc_eng_report_status (loc_eng_data_s_type &loc_eng_data, GpsStatusValue status)
2785 {
2786 ENTRY_LOG();
2787 // Switch from WAIT to MUTE, for "engine on" or "session begin" event
2788 if (status == GPS_STATUS_SESSION_BEGIN || status == GPS_STATUS_ENGINE_ON)
2789 {
2790 if (loc_eng_data.mute_session_state == LOC_MUTE_SESS_WAIT)
2791 {
2792 LOC_LOGD("loc_eng_report_status: mute_session_state changed from WAIT to IN SESSION");
2793 loc_eng_data.mute_session_state = LOC_MUTE_SESS_IN_SESSION;
2794 }
2795 }
2796
2797 // Switch off MUTE session
2798 if (loc_eng_data.mute_session_state == LOC_MUTE_SESS_IN_SESSION &&
2799 (status == GPS_STATUS_SESSION_END || status == GPS_STATUS_ENGINE_OFF))
2800 {
2801 LOC_LOGD("loc_eng_report_status: mute_session_state changed from IN SESSION to NONE");
2802 loc_eng_data.mute_session_state = LOC_MUTE_SESS_NONE;
2803 }
2804
2805 // Session End is not reported during Android navigating state
2806 boolean navigating = loc_eng_data.adapter->isInSession();
2807 if (status != GPS_STATUS_NONE &&
2808 !(status == GPS_STATUS_SESSION_END && navigating) &&
2809 !(status == GPS_STATUS_SESSION_BEGIN && !navigating))
2810 {
2811 if (loc_eng_data.mute_session_state != LOC_MUTE_SESS_IN_SESSION)
2812 {
2813 // Inform GpsLocationProvider about mNavigating status
2814 loc_inform_gps_status(loc_eng_data, status);
2815 }
2816 else {
2817 LOC_LOGD("loc_eng_report_status: muting the status report.");
2818 }
2819 }
2820
2821 // Only keeps ENGINE ON/OFF in engine_status
2822 if (status == GPS_STATUS_ENGINE_ON || status == GPS_STATUS_ENGINE_OFF)
2823 {
2824 loc_eng_data.engine_status = status;
2825 }
2826
2827 // Only keeps SESSION BEGIN/END in fix_session_status
2828 if (status == GPS_STATUS_SESSION_BEGIN || status == GPS_STATUS_SESSION_END)
2829 {
2830 loc_eng_data.fix_session_status = status;
2831 }
2832 EXIT_LOG(%s, VOID_RET);
2833 }
2834
2835 /*===========================================================================
2836 FUNCTION loc_eng_handle_engine_down
2837 loc_eng_handle_engine_up
2838
2839 DESCRIPTION
2840 Calls this function when it is detected that modem restart is happening.
2841 Either we detected the modem is down or received modem up event.
2842 This must be called from the deferred thread to avoid race condition.
2843
2844 DEPENDENCIES
2845 None
2846
2847 RETURN VALUE
2848 None
2849
2850 SIDE EFFECTS
2851 N/A
2852
2853 ===========================================================================*/
loc_eng_handle_engine_down(loc_eng_data_s_type & loc_eng_data)2854 void loc_eng_handle_engine_down(loc_eng_data_s_type &loc_eng_data)
2855 {
2856 ENTRY_LOG();
2857 loc_eng_ni_reset_on_engine_restart(loc_eng_data);
2858 loc_eng_report_status(loc_eng_data, GPS_STATUS_ENGINE_OFF);
2859 EXIT_LOG(%s, VOID_RET);
2860 }
2861
loc_eng_handle_engine_up(loc_eng_data_s_type & loc_eng_data)2862 void loc_eng_handle_engine_up(loc_eng_data_s_type &loc_eng_data)
2863 {
2864 ENTRY_LOG();
2865 loc_eng_reinit(loc_eng_data);
2866
2867 loc_eng_data.adapter->requestPowerVote();
2868
2869 if (loc_eng_data.agps_status_cb != NULL) {
2870 if (loc_eng_data.agnss_nif)
2871 loc_eng_data.agnss_nif->dropAllSubscribers();
2872 if (loc_eng_data.internet_nif)
2873 loc_eng_data.internet_nif->dropAllSubscribers();
2874
2875 loc_eng_agps_reinit(loc_eng_data);
2876 }
2877
2878 // modem is back up. If we crashed in the middle of navigating, we restart.
2879 if (loc_eng_data.adapter->isInSession()) {
2880 // This sets the copy in adapter to modem
2881 loc_eng_data.adapter->setInSession(false);
2882 loc_eng_data.adapter->sendMsg(new LocEngStartFix(loc_eng_data.adapter));
2883 }
2884 EXIT_LOG(%s, VOID_RET);
2885 }
2886
2887 #ifdef USE_GLIB
2888 /*===========================================================================
2889 FUNCTION set_sched_policy
2890
2891 DESCRIPTION
2892 Local copy of this function which bypasses android set_sched_policy
2893
2894 DEPENDENCIES
2895 None
2896
2897 RETURN VALUE
2898 0
2899
2900 SIDE EFFECTS
2901 N/A
2902
2903 ===========================================================================*/
set_sched_policy(int tid,SchedPolicy policy)2904 static int set_sched_policy(int tid, SchedPolicy policy)
2905 {
2906 return 0;
2907 }
2908 #endif /* USE_GLIB */
2909
2910 /*===========================================================================
2911 FUNCTION resolve_config_file_path
2912
2913 DESCRIPTION
2914 resolve the given config file path into a vaild full path considering that
2915 it could be located in vendor partition.
2916
2917 DEPENDENCIES
2918 None
2919
2920 RETURN VALUE
2921 None
2922
2923 SIDE EFFECTS
2924 N/A
2925
2926 ===========================================================================*/
resolve_config_file_path(const char * conf_file_name,char * resolved_file_path)2927 static void resolve_config_file_path(const char* conf_file_name,
2928 char* resolved_file_path) {
2929 FILE *file;
2930 if (conf_file_name[0] == '/') {
2931 sprintf(resolved_file_path, "/vendor%s", conf_file_name);
2932 } else {
2933 sprintf(resolved_file_path, "/vendor/%s", conf_file_name);
2934 }
2935 if ((file = fopen(resolved_file_path, "r")) != NULL) {
2936 fclose(file);
2937 return;
2938 }
2939 strcpy(resolved_file_path, conf_file_name);
2940 }
2941
2942 /*===========================================================================
2943 FUNCTION loc_eng_read_config
2944
2945 DESCRIPTION
2946 Initiates the reading of the gps config file stored in /etc dir
2947
2948 DEPENDENCIES
2949 None
2950
2951 RETURN VALUE
2952 0: success
2953
2954 SIDE EFFECTS
2955 N/A
2956
2957 ===========================================================================*/
loc_eng_read_config(void)2958 int loc_eng_read_config(void)
2959 {
2960 ENTRY_LOG_CALLFLOW();
2961 if(configAlreadyRead == false)
2962 {
2963 // Initialize our defaults before reading of configuration file overwrites them.
2964 loc_default_parameters();
2965 // We only want to parse the conf file once. This is a good place to ensure that.
2966 // In fact one day the conf file should go into context.
2967 char conf_file_name[256];
2968 resolve_config_file_path(GPS_CONF_FILE, conf_file_name);
2969 UTIL_READ_CONF(conf_file_name, gps_conf_table);
2970 resolve_config_file_path(SAP_CONF_FILE, conf_file_name);
2971 UTIL_READ_CONF(conf_file_name, sap_conf_table);
2972 configAlreadyRead = true;
2973 } else {
2974 LOC_LOGV("GPS Config file has already been read\n");
2975 }
2976
2977 EXIT_LOG(%d, 0);
2978 return 0;
2979 }
2980
2981 /*===========================================================================
2982 FUNCTION loc_eng_gps_measurement_init
2983
2984 DESCRIPTION
2985 Initialize gps measurement module.
2986
2987 DEPENDENCIES
2988 N/A
2989
2990 RETURN VALUE
2991 0: success
2992
2993 SIDE EFFECTS
2994 N/A
2995
2996 ===========================================================================*/
loc_eng_gps_measurement_init(loc_eng_data_s_type & loc_eng_data,GpsMeasurementCallbacks * callbacks)2997 int loc_eng_gps_measurement_init(loc_eng_data_s_type &loc_eng_data,
2998 GpsMeasurementCallbacks* callbacks)
2999 {
3000 ENTRY_LOG_CALLFLOW();
3001
3002 STATE_CHECK((NULL == loc_eng_data.gnss_measurement_cb),
3003 "gnss measurement already initialized",
3004 return GPS_MEASUREMENT_ERROR_ALREADY_INIT);
3005 STATE_CHECK((callbacks != NULL),
3006 "callbacks can not be NULL",
3007 return GPS_MEASUREMENT_ERROR_GENERIC);
3008 STATE_CHECK(loc_eng_data.adapter,
3009 "GpsInterface must be initialized first",
3010 return GPS_MEASUREMENT_ERROR_GENERIC);
3011
3012 // updated the mask
3013 LOC_API_ADAPTER_EVENT_MASK_T event = LOC_API_ADAPTER_BIT_GNSS_MEASUREMENT;
3014 loc_eng_data.adapter->sendMsg(new LocEngUpdateRegistrationMask(
3015 &loc_eng_data,
3016 event,
3017 LOC_REGISTRATION_MASK_ENABLED));
3018 // set up the callback
3019 loc_eng_data.gnss_measurement_cb = callbacks->gnss_measurement_callback;
3020 LOC_LOGD ("%s, event masks updated successfully", __func__);
3021
3022 return GPS_MEASUREMENT_OPERATION_SUCCESS;
3023 }
3024
3025 /*===========================================================================
3026 FUNCTION loc_eng_gps_measurement_close
3027
3028 DESCRIPTION
3029 Close gps measurement module.
3030
3031 DEPENDENCIES
3032 N/A
3033
3034 RETURN VALUE
3035 N/A
3036
3037 SIDE EFFECTS
3038 N/A
3039
3040 ===========================================================================*/
loc_eng_gps_measurement_close(loc_eng_data_s_type & loc_eng_data)3041 void loc_eng_gps_measurement_close(loc_eng_data_s_type &loc_eng_data)
3042 {
3043 ENTRY_LOG_CALLFLOW();
3044
3045 INIT_CHECK(loc_eng_data.adapter, return);
3046
3047 // updated the mask
3048 LOC_API_ADAPTER_EVENT_MASK_T event = LOC_API_ADAPTER_BIT_GNSS_MEASUREMENT;
3049 loc_eng_data.adapter->sendMsg(new LocEngUpdateRegistrationMask(
3050 &loc_eng_data,
3051 event,
3052 LOC_REGISTRATION_MASK_DISABLED));
3053 // set up the callback
3054 loc_eng_data.gnss_measurement_cb = NULL;
3055 EXIT_LOG(%d, 0);
3056 }
3057