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