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