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