1 /* Copyright (c) 2011-2014, The Linux Foundation. All rights reserved. 2 * 3 * Redistribution and use in source and binary forms, with or without 4 * modification, are permitted provided that the following conditions are 5 * met: 6 * * Redistributions of source code must retain the above copyright 7 * notice, this list of conditions and the following disclaimer. 8 * * Redistributions in binary form must reproduce the above 9 * copyright notice, this list of conditions and the following 10 * disclaimer in the documentation and/or other materials provided 11 * with the distribution. 12 * * Neither the name of The Linux Foundation, nor the names of its 13 * contributors may be used to endorse or promote products derived 14 * from this software without specific prior written permission. 15 * 16 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED 17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 18 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT 19 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS 20 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR 23 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 24 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 25 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN 26 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27 * 28 */ 29 #define LOG_NDDEBUG 0 30 #define LOG_TAG "LocSvc_LocApiBase" 31 32 #include <dlfcn.h> 33 #include <LocApiBase.h> 34 #include <LocAdapterBase.h> 35 #include <log_util.h> 36 #include <LocDualContext.h> 37 38 namespace loc_core { 39 40 #define TO_ALL_LOCADAPTERS(call) TO_ALL_ADAPTERS(mLocAdapters, (call)) 41 #define TO_1ST_HANDLING_LOCADAPTERS(call) TO_1ST_HANDLING_ADAPTER(mLocAdapters, (call)) 42 43 int hexcode(char *hexstring, int string_size, 44 const char *data, int data_size) 45 { 46 int i; 47 for (i = 0; i < data_size; i++) 48 { 49 char ch = data[i]; 50 if (i*2 + 3 <= string_size) 51 { 52 snprintf(&hexstring[i*2], 3, "%02X", ch); 53 } 54 else { 55 break; 56 } 57 } 58 return i; 59 } 60 61 int decodeAddress(char *addr_string, int string_size, 62 const char *data, int data_size) 63 { 64 const char addr_prefix = 0x91; 65 int i, idxOutput = 0; 66 67 if (!data || !addr_string) { return 0; } 68 69 if (data[0] != addr_prefix) 70 { 71 LOC_LOGW("decodeAddress: address prefix is not 0x%x but 0x%x", addr_prefix, data[0]); 72 addr_string[0] = '\0'; 73 return 0; // prefix not correct 74 } 75 76 for (i = 1; i < data_size; i++) 77 { 78 unsigned char ch = data[i], low = ch & 0x0F, hi = ch >> 4; 79 if (low <= 9 && idxOutput < string_size - 1) { addr_string[idxOutput++] = low + '0'; } 80 if (hi <= 9 && idxOutput < string_size - 1) { addr_string[idxOutput++] = hi + '0'; } 81 } 82 83 addr_string[idxOutput] = '\0'; // Terminates the string 84 85 return idxOutput; 86 } 87 88 struct LocSsrMsg : public LocMsg { 89 LocApiBase* mLocApi; 90 inline LocSsrMsg(LocApiBase* locApi) : 91 LocMsg(), mLocApi(locApi) 92 { 93 locallog(); 94 } 95 inline virtual void proc() const { 96 mLocApi->close(); 97 mLocApi->open(mLocApi->getEvtMask()); 98 } 99 inline void locallog() { 100 LOC_LOGV("LocSsrMsg"); 101 } 102 inline virtual void log() { 103 locallog(); 104 } 105 }; 106 107 struct LocOpenMsg : public LocMsg { 108 LocApiBase* mLocApi; 109 LOC_API_ADAPTER_EVENT_MASK_T mMask; 110 inline LocOpenMsg(LocApiBase* locApi, 111 LOC_API_ADAPTER_EVENT_MASK_T mask) : 112 LocMsg(), mLocApi(locApi), mMask(mask) 113 { 114 locallog(); 115 } 116 inline virtual void proc() const { 117 mLocApi->open(mMask); 118 } 119 inline void locallog() { 120 LOC_LOGV("%s:%d]: LocOpen Mask: %x\n", 121 __func__, __LINE__, mMask); 122 } 123 inline virtual void log() { 124 locallog(); 125 } 126 }; 127 128 LocApiBase::LocApiBase(const MsgTask* msgTask, 129 LOC_API_ADAPTER_EVENT_MASK_T excludedMask, 130 ContextBase* context) : 131 mExcludedMask(excludedMask), mMsgTask(msgTask), 132 mMask(0), mSupportedMsg(0), mContext(context) 133 { 134 memset(mLocAdapters, 0, sizeof(mLocAdapters)); 135 } 136 137 LOC_API_ADAPTER_EVENT_MASK_T LocApiBase::getEvtMask() 138 { 139 LOC_API_ADAPTER_EVENT_MASK_T mask = 0; 140 141 TO_ALL_LOCADAPTERS(mask |= mLocAdapters[i]->getEvtMask()); 142 143 return mask & ~mExcludedMask; 144 } 145 146 bool LocApiBase::isInSession() 147 { 148 bool inSession = false; 149 150 for (int i = 0; 151 !inSession && i < MAX_ADAPTERS && NULL != mLocAdapters[i]; 152 i++) { 153 inSession = mLocAdapters[i]->isInSession(); 154 } 155 156 return inSession; 157 } 158 159 void LocApiBase::addAdapter(LocAdapterBase* adapter) 160 { 161 for (int i = 0; i < MAX_ADAPTERS && mLocAdapters[i] != adapter; i++) { 162 if (mLocAdapters[i] == NULL) { 163 mLocAdapters[i] = adapter; 164 mMsgTask->sendMsg(new LocOpenMsg(this, 165 (adapter->getEvtMask()))); 166 break; 167 } 168 } 169 } 170 171 void LocApiBase::removeAdapter(LocAdapterBase* adapter) 172 { 173 for (int i = 0; 174 i < MAX_ADAPTERS && NULL != mLocAdapters[i]; 175 i++) { 176 if (mLocAdapters[i] == adapter) { 177 mLocAdapters[i] = NULL; 178 179 // shift the rest of the adapters up so that the pointers 180 // in the array do not have holes. This should be more 181 // performant, because the array maintenance is much much 182 // less frequent than event handlings, which need to linear 183 // search all the adapters 184 int j = i; 185 while (++i < MAX_ADAPTERS && mLocAdapters[i] != NULL); 186 187 // i would be MAX_ADAPTERS or point to a NULL 188 i--; 189 // i now should point to a none NULL adapter within valid 190 // range although i could be equal to j, but it won't hurt. 191 // No need to check it, as it gains nothing. 192 mLocAdapters[j] = mLocAdapters[i]; 193 // this makes sure that we exit the for loop 194 mLocAdapters[i] = NULL; 195 196 // if we have an empty list of adapters 197 if (0 == i) { 198 close(); 199 } else { 200 // else we need to remove the bit 201 mMsgTask->sendMsg(new LocOpenMsg(this, getEvtMask())); 202 } 203 } 204 } 205 } 206 207 void LocApiBase::updateEvtMask() 208 { 209 mMsgTask->sendMsg(new LocOpenMsg(this, getEvtMask())); 210 } 211 212 void LocApiBase::handleEngineUpEvent() 213 { 214 // This will take care of renegotiating the loc handle 215 mMsgTask->sendMsg(new LocSsrMsg(this)); 216 217 LocDualContext::injectFeatureConfig(mContext); 218 219 // loop through adapters, and deliver to all adapters. 220 TO_ALL_LOCADAPTERS(mLocAdapters[i]->handleEngineUpEvent()); 221 } 222 223 void LocApiBase::handleEngineDownEvent() 224 { 225 // loop through adapters, and deliver to all adapters. 226 TO_ALL_LOCADAPTERS(mLocAdapters[i]->handleEngineDownEvent()); 227 } 228 229 void LocApiBase::reportPosition(UlpLocation &location, 230 GpsLocationExtended &locationExtended, 231 void* locationExt, 232 enum loc_sess_status status, 233 LocPosTechMask loc_technology_mask) 234 { 235 // print the location info before delivering 236 LOC_LOGV("flags: %d\n source: %d\n latitude: %f\n longitude: %f\n " 237 "altitude: %f\n speed: %f\n bearing: %f\n accuracy: %f\n " 238 "timestamp: %lld\n rawDataSize: %d\n rawData: %p\n " 239 "Session status: %d\n Technology mask: %u", 240 location.gpsLocation.flags, location.position_source, 241 location.gpsLocation.latitude, location.gpsLocation.longitude, 242 location.gpsLocation.altitude, location.gpsLocation.speed, 243 location.gpsLocation.bearing, location.gpsLocation.accuracy, 244 location.gpsLocation.timestamp, location.rawDataSize, 245 location.rawData, status, loc_technology_mask); 246 // loop through adapters, and deliver to all adapters. 247 TO_ALL_LOCADAPTERS( 248 mLocAdapters[i]->reportPosition(location, 249 locationExtended, 250 locationExt, 251 status, 252 loc_technology_mask) 253 ); 254 } 255 256 void LocApiBase::reportSv(QtiGnssSvStatus &svStatus, 257 GpsLocationExtended &locationExtended, 258 void* svExt) 259 { 260 // print the SV info before delivering 261 LOC_LOGV("num sv: %d\n ephemeris mask: %dxn almanac mask: %x\n gps/glo/bds in use" 262 " mask: %x/%x/%x\n sv: prn snr elevation azimuth", 263 svStatus.num_svs, svStatus.ephemeris_mask, 264 svStatus.almanac_mask, svStatus.gps_used_in_fix_mask, 265 svStatus.glo_used_in_fix_mask, svStatus.bds_used_in_fix_mask); 266 for (int i = 0; i < svStatus.num_svs && i < GPS_MAX_SVS; i++) { 267 LOC_LOGV(" %d: %d %f %f %f", 268 i, 269 svStatus.sv_list[i].prn, 270 svStatus.sv_list[i].snr, 271 svStatus.sv_list[i].elevation, 272 svStatus.sv_list[i].azimuth); 273 } 274 // loop through adapters, and deliver to all adapters. 275 TO_ALL_LOCADAPTERS( 276 mLocAdapters[i]->reportSv(svStatus, 277 locationExtended, 278 svExt) 279 ); 280 } 281 282 void LocApiBase::reportStatus(GpsStatusValue status) 283 { 284 // loop through adapters, and deliver to all adapters. 285 TO_ALL_LOCADAPTERS(mLocAdapters[i]->reportStatus(status)); 286 } 287 288 void LocApiBase::reportNmea(const char* nmea, int length) 289 { 290 // loop through adapters, and deliver to all adapters. 291 TO_ALL_LOCADAPTERS(mLocAdapters[i]->reportNmea(nmea, length)); 292 } 293 294 void LocApiBase::reportXtraServer(const char* url1, const char* url2, 295 const char* url3, const int maxlength) 296 { 297 // loop through adapters, and deliver to the first handling adapter. 298 TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->reportXtraServer(url1, url2, url3, maxlength)); 299 300 } 301 302 void LocApiBase::requestXtraData() 303 { 304 // loop through adapters, and deliver to the first handling adapter. 305 TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->requestXtraData()); 306 } 307 308 void LocApiBase::requestTime() 309 { 310 // loop through adapters, and deliver to the first handling adapter. 311 TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->requestTime()); 312 } 313 314 void LocApiBase::requestLocation() 315 { 316 // loop through adapters, and deliver to the first handling adapter. 317 TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->requestLocation()); 318 } 319 320 void LocApiBase::requestATL(int connHandle, AGpsType agps_type) 321 { 322 // loop through adapters, and deliver to the first handling adapter. 323 TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->requestATL(connHandle, agps_type)); 324 } 325 326 void LocApiBase::releaseATL(int connHandle) 327 { 328 // loop through adapters, and deliver to the first handling adapter. 329 TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->releaseATL(connHandle)); 330 } 331 332 void LocApiBase::requestSuplES(int connHandle) 333 { 334 // loop through adapters, and deliver to the first handling adapter. 335 TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->requestSuplES(connHandle)); 336 } 337 338 void LocApiBase::reportDataCallOpened() 339 { 340 // loop through adapters, and deliver to the first handling adapter. 341 TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->reportDataCallOpened()); 342 } 343 344 void LocApiBase::reportDataCallClosed() 345 { 346 // loop through adapters, and deliver to the first handling adapter. 347 TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->reportDataCallClosed()); 348 } 349 350 void LocApiBase::requestNiNotify(GpsNiNotification ¬ify, const void* data) 351 { 352 // loop through adapters, and deliver to the first handling adapter. 353 TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->requestNiNotify(notify, data)); 354 } 355 356 void LocApiBase::saveSupportedMsgList(uint64_t supportedMsgList) 357 { 358 mSupportedMsg = supportedMsgList; 359 } 360 361 void* LocApiBase :: getSibling() 362 DEFAULT_IMPL(NULL) 363 364 LocApiProxyBase* LocApiBase :: getLocApiProxy() 365 DEFAULT_IMPL(NULL) 366 367 void LocApiBase::reportGpsMeasurementData(GpsData &gpsMeasurementData) 368 { 369 // loop through adapters, and deliver to all adapters. 370 TO_ALL_LOCADAPTERS(mLocAdapters[i]->reportGpsMeasurementData(gpsMeasurementData)); 371 } 372 373 enum loc_api_adapter_err LocApiBase:: 374 open(LOC_API_ADAPTER_EVENT_MASK_T mask) 375 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) 376 377 enum loc_api_adapter_err LocApiBase:: 378 close() 379 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) 380 381 enum loc_api_adapter_err LocApiBase:: 382 startFix(const LocPosMode& posMode) 383 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) 384 385 enum loc_api_adapter_err LocApiBase:: 386 stopFix() 387 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) 388 389 enum loc_api_adapter_err LocApiBase:: 390 deleteAidingData(GpsAidingData f) 391 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) 392 393 enum loc_api_adapter_err LocApiBase:: 394 enableData(int enable) 395 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) 396 397 enum loc_api_adapter_err LocApiBase:: 398 setAPN(char* apn, int len) 399 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) 400 401 enum loc_api_adapter_err LocApiBase:: 402 injectPosition(double latitude, double longitude, float accuracy) 403 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) 404 405 enum loc_api_adapter_err LocApiBase:: 406 setTime(GpsUtcTime time, int64_t timeReference, int uncertainty) 407 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) 408 409 enum loc_api_adapter_err LocApiBase:: 410 setXtraData(char* data, int length) 411 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) 412 413 enum loc_api_adapter_err LocApiBase:: 414 requestXtraServer() 415 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) 416 417 enum loc_api_adapter_err LocApiBase:: 418 atlOpenStatus(int handle, int is_succ, char* apn, 419 AGpsBearerType bear, AGpsType agpsType) 420 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) 421 422 enum loc_api_adapter_err LocApiBase:: 423 atlCloseStatus(int handle, int is_succ) 424 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) 425 426 enum loc_api_adapter_err LocApiBase:: 427 setPositionMode(const LocPosMode& posMode) 428 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) 429 430 enum loc_api_adapter_err LocApiBase:: 431 setServer(const char* url, int len) 432 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) 433 434 enum loc_api_adapter_err LocApiBase:: 435 setServer(unsigned int ip, int port, 436 LocServerType type) 437 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) 438 439 enum loc_api_adapter_err LocApiBase:: 440 informNiResponse(GpsUserResponseType userResponse, 441 const void* passThroughData) 442 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) 443 444 enum loc_api_adapter_err LocApiBase:: 445 setSUPLVersion(uint32_t version) 446 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) 447 448 enum loc_api_adapter_err LocApiBase:: 449 setLPPConfig(uint32_t profile) 450 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) 451 452 enum loc_api_adapter_err LocApiBase:: 453 setSensorControlConfig(int sensorUsage, 454 int sensorProvider) 455 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) 456 457 enum loc_api_adapter_err LocApiBase:: 458 setSensorProperties(bool gyroBiasVarianceRandomWalk_valid, 459 float gyroBiasVarianceRandomWalk, 460 bool accelBiasVarianceRandomWalk_valid, 461 float accelBiasVarianceRandomWalk, 462 bool angleBiasVarianceRandomWalk_valid, 463 float angleBiasVarianceRandomWalk, 464 bool rateBiasVarianceRandomWalk_valid, 465 float rateBiasVarianceRandomWalk, 466 bool velocityBiasVarianceRandomWalk_valid, 467 float velocityBiasVarianceRandomWalk) 468 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) 469 470 enum loc_api_adapter_err LocApiBase:: 471 setSensorPerfControlConfig(int controlMode, 472 int accelSamplesPerBatch, 473 int accelBatchesPerSec, 474 int gyroSamplesPerBatch, 475 int gyroBatchesPerSec, 476 int accelSamplesPerBatchHigh, 477 int accelBatchesPerSecHigh, 478 int gyroSamplesPerBatchHigh, 479 int gyroBatchesPerSecHigh, 480 int algorithmConfig) 481 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) 482 483 enum loc_api_adapter_err LocApiBase:: 484 setExtPowerConfig(int isBatteryCharging) 485 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) 486 487 enum loc_api_adapter_err LocApiBase:: 488 setAGLONASSProtocol(unsigned long aGlonassProtocol) 489 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) 490 491 enum loc_api_adapter_err LocApiBase:: 492 getWwanZppFix(GpsLocation& zppLoc) 493 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) 494 495 enum loc_api_adapter_err LocApiBase:: 496 getBestAvailableZppFix(GpsLocation& zppLoc) 497 { 498 memset(&zppLoc, 0, sizeof(zppLoc)); 499 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) 500 } 501 502 enum loc_api_adapter_err LocApiBase:: 503 getBestAvailableZppFix(GpsLocation & zppLoc, LocPosTechMask & tech_mask) 504 { 505 memset(&zppLoc, 0, sizeof(zppLoc)); 506 memset(&tech_mask, 0, sizeof(tech_mask)); 507 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) 508 } 509 510 int LocApiBase:: 511 initDataServiceClient() 512 DEFAULT_IMPL(-1) 513 514 int LocApiBase:: 515 openAndStartDataCall() 516 DEFAULT_IMPL(-1) 517 518 void LocApiBase:: 519 stopDataCall() 520 DEFAULT_IMPL() 521 522 void LocApiBase:: 523 closeDataCall() 524 DEFAULT_IMPL() 525 526 int LocApiBase:: 527 setGpsLock(LOC_GPS_LOCK_MASK lock) 528 DEFAULT_IMPL(-1) 529 530 void LocApiBase:: 531 installAGpsCert(const DerEncodedCertificate* pData, 532 size_t length, 533 uint32_t slotBitMask) 534 DEFAULT_IMPL() 535 536 int LocApiBase:: 537 getGpsLock() 538 DEFAULT_IMPL(-1) 539 540 enum loc_api_adapter_err LocApiBase:: 541 setXtraVersionCheck(enum xtra_version_check check) 542 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) 543 544 int LocApiBase:: 545 updateRegistrationMask(LOC_API_ADAPTER_EVENT_MASK_T event, 546 loc_registration_mask_status isEnabled) 547 DEFAULT_IMPL(-1) 548 549 bool LocApiBase:: 550 gnssConstellationConfig() 551 DEFAULT_IMPL(false) 552 553 } // namespace loc_core 554
