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