Home | History | Annotate | Download | only in core 
      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(GnssSvStatus &svStatus,
    257                   GpsLocationExtended &locationExtended,
    258                   void* svExt)
    259 {
    260     // print the SV info before delivering
    261     LOC_LOGV("num sv: %d", svStatus.num_svs);
    262     for (int i = 0; i < svStatus.num_svs && i < GNSS_MAX_SVS; i++) {
    263         LOC_LOGV("   %03d:   %02d    %d    %f    %f    %f   0x%02X",
    264                  i,
    265                  svStatus.gnss_sv_list[i].svid,
    266                  svStatus.gnss_sv_list[i].constellation,
    267                  svStatus.gnss_sv_list[i].c_n0_dbhz,
    268                  svStatus.gnss_sv_list[i].elevation,
    269                  svStatus.gnss_sv_list[i].azimuth,
    270                  svStatus.gnss_sv_list[i].flags);
    271     }
    272     // loop through adapters, and deliver to all adapters.
    273     TO_ALL_LOCADAPTERS(
    274         mLocAdapters[i]->reportSv(svStatus,
    275                                      locationExtended,
    276                                      svExt)
    277     );
    278 }
    279 
    280 void LocApiBase::reportStatus(GpsStatusValue status)
    281 {
    282     // loop through adapters, and deliver to all adapters.
    283     TO_ALL_LOCADAPTERS(mLocAdapters[i]->reportStatus(status));
    284 }
    285 
    286 void LocApiBase::reportNmea(const char* nmea, int length)
    287 {
    288     // loop through adapters, and deliver to all adapters.
    289     TO_ALL_LOCADAPTERS(mLocAdapters[i]->reportNmea(nmea, length));
    290 }
    291 
    292 void LocApiBase::reportXtraServer(const char* url1, const char* url2,
    293                                   const char* url3, const int maxlength)
    294 {
    295     // loop through adapters, and deliver to the first handling adapter.
    296     TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->reportXtraServer(url1, url2, url3, maxlength));
    297 
    298 }
    299 
    300 void LocApiBase::requestXtraData()
    301 {
    302     // loop through adapters, and deliver to the first handling adapter.
    303     TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->requestXtraData());
    304 }
    305 
    306 void LocApiBase::requestTime()
    307 {
    308     // loop through adapters, and deliver to the first handling adapter.
    309     TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->requestTime());
    310 }
    311 
    312 void LocApiBase::requestLocation()
    313 {
    314     // loop through adapters, and deliver to the first handling adapter.
    315     TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->requestLocation());
    316 }
    317 
    318 void LocApiBase::requestATL(int connHandle, AGpsType agps_type)
    319 {
    320     // loop through adapters, and deliver to the first handling adapter.
    321     TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->requestATL(connHandle, agps_type));
    322 }
    323 
    324 void LocApiBase::releaseATL(int connHandle)
    325 {
    326     // loop through adapters, and deliver to the first handling adapter.
    327     TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->releaseATL(connHandle));
    328 }
    329 
    330 void LocApiBase::requestSuplES(int connHandle)
    331 {
    332     // loop through adapters, and deliver to the first handling adapter.
    333     TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->requestSuplES(connHandle));
    334 }
    335 
    336 void LocApiBase::reportDataCallOpened()
    337 {
    338     // loop through adapters, and deliver to the first handling adapter.
    339     TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->reportDataCallOpened());
    340 }
    341 
    342 void LocApiBase::reportDataCallClosed()
    343 {
    344     // loop through adapters, and deliver to the first handling adapter.
    345     TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->reportDataCallClosed());
    346 }
    347 
    348 void LocApiBase::requestNiNotify(GpsNiNotification &notify, const void* data)
    349 {
    350     // loop through adapters, and deliver to the first handling adapter.
    351     TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->requestNiNotify(notify, data));
    352 }
    353 
    354 void LocApiBase::saveSupportedMsgList(uint64_t supportedMsgList)
    355 {
    356     mSupportedMsg = supportedMsgList;
    357 }
    358 
    359 void* LocApiBase :: getSibling()
    360     DEFAULT_IMPL(NULL)
    361 
    362 LocApiProxyBase* LocApiBase :: getLocApiProxy()
    363     DEFAULT_IMPL(NULL)
    364 
    365 void LocApiBase::reportGnssMeasurementData(GnssData &gnssMeasurementData)
    366 {
    367     // loop through adapters, and deliver to all adapters.
    368     TO_ALL_LOCADAPTERS(mLocAdapters[i]->reportGnssMeasurementData(gnssMeasurementData));
    369 }
    370 
    371 enum loc_api_adapter_err LocApiBase::
    372    open(LOC_API_ADAPTER_EVENT_MASK_T mask)
    373 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
    374 
    375 enum loc_api_adapter_err LocApiBase::
    376     close()
    377 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
    378 
    379 enum loc_api_adapter_err LocApiBase::
    380     startFix(const LocPosMode& posMode)
    381 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
    382 
    383 enum loc_api_adapter_err LocApiBase::
    384     stopFix()
    385 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
    386 
    387 enum loc_api_adapter_err LocApiBase::
    388     deleteAidingData(GpsAidingData f)
    389 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
    390 
    391 enum loc_api_adapter_err LocApiBase::
    392     enableData(int enable)
    393 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
    394 
    395 enum loc_api_adapter_err LocApiBase::
    396     setAPN(char* apn, int len)
    397 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
    398 
    399 enum loc_api_adapter_err LocApiBase::
    400     injectPosition(double latitude, double longitude, float accuracy)
    401 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
    402 
    403 enum loc_api_adapter_err LocApiBase::
    404     setTime(GpsUtcTime time, int64_t timeReference, int uncertainty)
    405 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
    406 
    407 enum loc_api_adapter_err LocApiBase::
    408     setXtraData(char* data, int length)
    409 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
    410 
    411 enum loc_api_adapter_err LocApiBase::
    412     requestXtraServer()
    413 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
    414 
    415 enum loc_api_adapter_err LocApiBase::
    416    atlOpenStatus(int handle, int is_succ, char* apn,
    417                  AGpsBearerType bear, AGpsType agpsType)
    418 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
    419 
    420 enum loc_api_adapter_err LocApiBase::
    421     atlCloseStatus(int handle, int is_succ)
    422 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
    423 
    424 enum loc_api_adapter_err LocApiBase::
    425     setPositionMode(const LocPosMode& posMode)
    426 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
    427 
    428 enum loc_api_adapter_err LocApiBase::
    429     setServer(const char* url, int len)
    430 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
    431 
    432 enum loc_api_adapter_err LocApiBase::
    433     setServer(unsigned int ip, int port,
    434               LocServerType type)
    435 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
    436 
    437 enum loc_api_adapter_err LocApiBase::
    438     informNiResponse(GpsUserResponseType userResponse,
    439                      const void* passThroughData)
    440 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
    441 
    442 enum loc_api_adapter_err LocApiBase::
    443     setSUPLVersion(uint32_t version)
    444 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
    445 
    446 enum loc_api_adapter_err LocApiBase::
    447     setLPPConfig(uint32_t profile)
    448 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
    449 
    450 enum loc_api_adapter_err LocApiBase::
    451     setSensorControlConfig(int sensorUsage,
    452                            int sensorProvider)
    453 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
    454 
    455 enum loc_api_adapter_err LocApiBase::
    456     setSensorProperties(bool gyroBiasVarianceRandomWalk_valid,
    457                         float gyroBiasVarianceRandomWalk,
    458                         bool accelBiasVarianceRandomWalk_valid,
    459                         float accelBiasVarianceRandomWalk,
    460                         bool angleBiasVarianceRandomWalk_valid,
    461                         float angleBiasVarianceRandomWalk,
    462                         bool rateBiasVarianceRandomWalk_valid,
    463                         float rateBiasVarianceRandomWalk,
    464                         bool velocityBiasVarianceRandomWalk_valid,
    465                         float velocityBiasVarianceRandomWalk)
    466 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
    467 
    468 enum loc_api_adapter_err LocApiBase::
    469     setSensorPerfControlConfig(int controlMode,
    470                                int accelSamplesPerBatch,
    471                                int accelBatchesPerSec,
    472                                int gyroSamplesPerBatch,
    473                                int gyroBatchesPerSec,
    474                                int accelSamplesPerBatchHigh,
    475                                int accelBatchesPerSecHigh,
    476                                int gyroSamplesPerBatchHigh,
    477                                int gyroBatchesPerSecHigh,
    478                                int algorithmConfig)
    479 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
    480 
    481 enum loc_api_adapter_err LocApiBase::
    482     setExtPowerConfig(int isBatteryCharging)
    483 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
    484 
    485 enum loc_api_adapter_err LocApiBase::
    486     setAGLONASSProtocol(unsigned long aGlonassProtocol)
    487 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
    488 
    489 enum loc_api_adapter_err LocApiBase::
    490    getWwanZppFix(GpsLocation& zppLoc)
    491 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
    492 
    493 enum loc_api_adapter_err LocApiBase::
    494    getBestAvailableZppFix(GpsLocation& zppLoc)
    495 {
    496    memset(&zppLoc, 0, sizeof(zppLoc));
    497    DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
    498 }
    499 
    500 enum loc_api_adapter_err LocApiBase::
    501    getBestAvailableZppFix(GpsLocation & zppLoc, LocPosTechMask & tech_mask)
    502 {
    503    memset(&zppLoc, 0, sizeof(zppLoc));
    504    memset(&tech_mask, 0, sizeof(tech_mask));
    505    DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
    506 }
    507 
    508 int LocApiBase::
    509     initDataServiceClient()
    510 DEFAULT_IMPL(-1)
    511 
    512 int LocApiBase::
    513     openAndStartDataCall()
    514 DEFAULT_IMPL(-1)
    515 
    516 void LocApiBase::
    517     stopDataCall()
    518 DEFAULT_IMPL()
    519 
    520 void LocApiBase::
    521     closeDataCall()
    522 DEFAULT_IMPL()
    523 
    524 int LocApiBase::
    525     setGpsLock(LOC_GPS_LOCK_MASK lock)
    526 DEFAULT_IMPL(-1)
    527 
    528 void LocApiBase::
    529     installAGpsCert(const DerEncodedCertificate* pData,
    530                     size_t length,
    531                     uint32_t slotBitMask)
    532 DEFAULT_IMPL()
    533 
    534 int LocApiBase::
    535     getGpsLock()
    536 DEFAULT_IMPL(-1)
    537 
    538 enum loc_api_adapter_err LocApiBase::
    539     setXtraVersionCheck(enum xtra_version_check check)
    540 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
    541 
    542 int LocApiBase::
    543     updateRegistrationMask(LOC_API_ADAPTER_EVENT_MASK_T event,
    544                            loc_registration_mask_status isEnabled)
    545 DEFAULT_IMPL(-1)
    546 
    547 bool LocApiBase::
    548     gnssConstellationConfig()
    549 DEFAULT_IMPL(false)
    550 
    551 } // namespace loc_core
    552