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