Home | History | Annotate | Download | only in location 
      1 /* Copyright (c) 2017 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_APIClientBase"
     31 
     32 #include <log_util.h>
     33 #include <loc_cfg.h>
     34 #include "LocationAPIClientBase.h"
     35 
     36 #define FLP_CONF_FILE "/vendor/etc/flp.conf"
     37 
     38 LocationAPIClientBase::LocationAPIClientBase() :
     39     mTrackingCallback(nullptr),
     40     mBatchingCallback(nullptr),
     41     mGeofenceBreachCallback(nullptr),
     42     mLocationAPI(nullptr),
     43     mLocationControlAPI(nullptr),
     44     mBatchSize(-1)
     45 {
     46 
     47     // use recursive mutex, in case callback come from the same thread
     48     pthread_mutexattr_t attr;
     49     pthread_mutexattr_init(&attr);
     50     pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
     51     pthread_mutex_init(&mMutex, &attr);
     52 
     53     for (int i = 0; i < REQUEST_MAX; i++) {
     54         mRequestQueues[i] = nullptr;
     55     }
     56 
     57     memset(&mConfig, 0, sizeof(GnssConfig));
     58 }
     59 
     60 void LocationAPIClientBase::locAPISetCallbacks(LocationCallbacks& locationCallbacks)
     61 {
     62     if (locationCallbacks.geofenceBreachCb != nullptr) {
     63         mGeofenceBreachCallback = locationCallbacks.geofenceBreachCb;
     64         locationCallbacks.geofenceBreachCb =
     65             [this](GeofenceBreachNotification geofenceBreachNotification) {
     66                 beforeGeofenceBreachCb(geofenceBreachNotification);
     67             };
     68     }
     69 
     70     locationCallbacks.capabilitiesCb =
     71         [this](LocationCapabilitiesMask capabilitiesMask) {
     72             onCapabilitiesCb(capabilitiesMask);
     73         };
     74     locationCallbacks.responseCb = [this](LocationError error, uint32_t id) {
     75         onResponseCb(error, id);
     76     };
     77     locationCallbacks.collectiveResponseCb =
     78         [this](size_t count, LocationError* errors, uint32_t* ids) {
     79             onCollectiveResponseCb(count, errors, ids);
     80         };
     81 
     82     if (mLocationAPI == nullptr ) {
     83         mLocationAPI = LocationAPI::createInstance(locationCallbacks);
     84     } else {
     85         mLocationAPI->updateCallbacks(locationCallbacks);
     86     }
     87 
     88     if (mLocationControlAPI == nullptr) {
     89         LocationControlCallbacks locationControlCallbacks;
     90         locationControlCallbacks.size = sizeof(LocationControlCallbacks);
     91 
     92         locationControlCallbacks.responseCb =
     93             [this](LocationError error, uint32_t id) {
     94                 onCtrlResponseCb(error, id);
     95             };
     96         locationControlCallbacks.collectiveResponseCb =
     97             [this](size_t count, LocationError* errors, uint32_t* ids) {
     98                 onCtrlCollectiveResponseCb(count, errors, ids);
     99             };
    100 
    101         mLocationControlAPI = LocationControlAPI::createInstance(locationControlCallbacks);
    102     }
    103 }
    104 
    105 LocationAPIClientBase::~LocationAPIClientBase()
    106 {
    107     if (mLocationAPI) {
    108         mLocationAPI->destroy();
    109         mLocationAPI = nullptr;
    110     }
    111     if (mLocationControlAPI) {
    112         mLocationControlAPI->destroy();
    113         mLocationControlAPI = nullptr;
    114     }
    115 
    116     pthread_mutex_lock(&mMutex);
    117     for (int i = 0; i < REQUEST_MAX; i++) {
    118         if (mRequestQueues[i]) {
    119             delete mRequestQueues[i];
    120             mRequestQueues[i] = nullptr;
    121         }
    122     }
    123     pthread_mutex_unlock(&mMutex);
    124 
    125     pthread_mutex_destroy(&mMutex);
    126 }
    127 
    128 uint32_t LocationAPIClientBase::locAPIStartTracking(LocationOptions& options)
    129 {
    130     uint32_t retVal = LOCATION_ERROR_GENERAL_FAILURE;
    131     if (mLocationAPI) {
    132         pthread_mutex_lock(&mMutex);
    133         RequestQueue* requests = mRequestQueues[REQUEST_TRACKING];
    134         if (requests) {
    135             delete requests;
    136         }
    137         uint32_t session = mLocationAPI->startTracking(options);
    138         LOC_LOGI("%s:%d] start new session: %d", __FUNCTION__, __LINE__, session);
    139         // onResponseCb might be called from other thread immediately after
    140         // startTracking returns, so we are not going to unlock mutex
    141         // until StartTrackingRequest is pushed into mRequestQueues[REQUEST_TRACKING]
    142         requests = new RequestQueue(session);
    143         requests->push(new StartTrackingRequest(*this));
    144         mRequestQueues[REQUEST_TRACKING] = requests;
    145         pthread_mutex_unlock(&mMutex);
    146 
    147         retVal = LOCATION_ERROR_SUCCESS;
    148     }
    149 
    150     return retVal;
    151 }
    152 
    153 void LocationAPIClientBase::locAPIStopTracking()
    154 {
    155     if (mLocationAPI) {
    156         pthread_mutex_lock(&mMutex);
    157         uint32_t session = -1;
    158         RequestQueue* requests = mRequestQueues[REQUEST_TRACKING];
    159         if (requests) {
    160             session = requests->getSession();
    161             requests->push(new StopTrackingRequest(*this));
    162             mLocationAPI->stopTracking(session);
    163         }
    164         pthread_mutex_unlock(&mMutex);
    165     }
    166 }
    167 
    168 void LocationAPIClientBase::locAPIUpdateTrackingOptions(LocationOptions& options)
    169 {
    170     if (mLocationAPI) {
    171         pthread_mutex_lock(&mMutex);
    172         uint32_t session = -1;
    173         RequestQueue* requests = mRequestQueues[REQUEST_TRACKING];
    174         if (requests) {
    175             session = requests->getSession();
    176             requests->push(new UpdateTrackingOptionsRequest(*this));
    177             mLocationAPI->updateTrackingOptions(session, options);
    178         }
    179         pthread_mutex_unlock(&mMutex);
    180     }
    181 }
    182 
    183 int32_t LocationAPIClientBase::locAPIGetBatchSize()
    184 {
    185     if (mBatchSize == -1) {
    186         const loc_param_s_type flp_conf_param_table[] =
    187         {
    188             {"BATCH_SIZE", &mBatchSize, nullptr, 'n'},
    189         };
    190         UTIL_READ_CONF(FLP_CONF_FILE, flp_conf_param_table);
    191         if (mBatchSize < 0) {
    192             // set mBatchSize to 0 if we got an illegal value from config file
    193             mBatchSize = 0;
    194         }
    195     }
    196     return mBatchSize;
    197 }
    198 
    199 
    200 uint32_t LocationAPIClientBase::locAPIStartSession(uint32_t id, uint32_t sessionMode,
    201         LocationOptions& options)
    202 {
    203     uint32_t retVal = LOCATION_ERROR_GENERAL_FAILURE;
    204     if (mLocationAPI) {
    205         pthread_mutex_lock(&mMutex);
    206 
    207         if (mSessionMap.find(id) != mSessionMap.end()) {
    208             LOC_LOGE("%s:%d] session %d has already started.", __FUNCTION__, __LINE__, id);
    209             retVal = LOCATION_ERROR_ALREADY_STARTED;
    210         } else {
    211             uint32_t trackingSession = 0;
    212             uint32_t batchingSession = 0;
    213 
    214             if (sessionMode == SESSION_MODE_ON_FIX) {
    215                 RequestQueue* requests = mRequestQueues[REQUEST_TRACKING];
    216                 if (requests) {
    217                     delete requests;
    218                 }
    219                 trackingSession = mLocationAPI->startTracking(options);
    220                 LOC_LOGI("%s:%d] start new session: %d", __FUNCTION__, __LINE__, trackingSession);
    221                 requests = new RequestQueue(trackingSession);
    222                 requests->push(new StartTrackingRequest(*this));
    223                 mRequestQueues[REQUEST_TRACKING] = requests;
    224             } else if (sessionMode == SESSION_MODE_ON_FULL) {
    225                 RequestQueue* requests = mRequestQueues[REQUEST_BATCHING];
    226                 if (requests) {
    227                     delete requests;
    228                 }
    229                 batchingSession = mLocationAPI->startBatching(options);
    230                 LOC_LOGI("%s:%d] start new session: %d", __FUNCTION__, __LINE__, batchingSession);
    231                 requests = new RequestQueue(batchingSession);
    232                 requests->push(new StartBatchingRequest(*this));
    233                 mRequestQueues[REQUEST_BATCHING] = requests;
    234             }
    235 
    236             SessionEntity entity;
    237             entity.id = id;
    238             entity.trackingSession = trackingSession;
    239             entity.batchingSession = batchingSession;
    240             entity.sessionMode = sessionMode;
    241             mSessionMap[id] = entity;
    242 
    243             retVal = LOCATION_ERROR_SUCCESS;
    244         }
    245 
    246         pthread_mutex_unlock(&mMutex);
    247     }
    248 
    249     return retVal;
    250 }
    251 
    252 uint32_t LocationAPIClientBase::locAPIStopSession(uint32_t id)
    253 {
    254     uint32_t retVal = LOCATION_ERROR_GENERAL_FAILURE;
    255     if (mLocationAPI) {
    256         pthread_mutex_lock(&mMutex);
    257 
    258         if (mSessionMap.find(id) != mSessionMap.end()) {
    259             SessionEntity entity = mSessionMap[id];
    260 
    261             uint32_t trackingSession = entity.trackingSession;
    262             uint32_t batchingSession = entity.batchingSession;
    263             uint32_t sMode = entity.sessionMode;
    264 
    265             mSessionMap.erase(id);
    266 
    267             if (sMode == SESSION_MODE_ON_FIX) {
    268                 RequestQueue* requests = mRequestQueues[REQUEST_TRACKING];
    269                 if (requests) {
    270                     requests->push(new StopTrackingRequest(*this));
    271                     mLocationAPI->stopTracking(trackingSession);
    272                 }
    273             } else if (sMode == SESSION_MODE_ON_FULL) {
    274                 RequestQueue* requests = mRequestQueues[REQUEST_BATCHING];
    275                 if (requests) {
    276                     requests->push(new StopBatchingRequest(*this));
    277                     mLocationAPI->stopBatching(batchingSession);
    278                 }
    279             }
    280 
    281             retVal = LOCATION_ERROR_SUCCESS;
    282         } else {
    283             retVal = LOCATION_ERROR_ID_UNKNOWN;
    284             LOC_LOGE("%s:%d] session %d is not exist.", __FUNCTION__, __LINE__, id);
    285         }
    286 
    287         pthread_mutex_unlock(&mMutex);
    288     }
    289     return retVal;
    290 }
    291 
    292 uint32_t LocationAPIClientBase::locAPIUpdateSessionOptions(uint32_t id, uint32_t sessionMode,
    293         LocationOptions& options)
    294 {
    295     uint32_t retVal = LOCATION_ERROR_GENERAL_FAILURE;
    296     if (mLocationAPI) {
    297         pthread_mutex_lock(&mMutex);
    298 
    299         if (mSessionMap.find(id) != mSessionMap.end()) {
    300             SessionEntity& entity = mSessionMap[id];
    301 
    302             uint32_t trackingSession = entity.trackingSession;
    303             uint32_t batchingSession = entity.batchingSession;
    304             uint32_t sMode = entity.sessionMode;
    305 
    306             if (sessionMode == SESSION_MODE_ON_FIX) {
    307                 if (sMode == SESSION_MODE_ON_FIX) {
    308                     RequestQueue* requests = mRequestQueues[REQUEST_TRACKING];
    309                     if (requests) {
    310                         requests->push(new UpdateTrackingOptionsRequest(*this));
    311                         mLocationAPI->updateTrackingOptions(trackingSession, options);
    312                     }
    313                 } else if (sMode == SESSION_MODE_ON_FULL) {
    314                     // stop batching
    315                     {
    316                         RequestQueue* requests = mRequestQueues[REQUEST_BATCHING];
    317                         if (requests) {
    318                             requests->push(new StopBatchingRequest(*this));
    319                             mLocationAPI->stopBatching(batchingSession);
    320                             batchingSession = 0;
    321                         }
    322                     }
    323                     // start tracking
    324                     {
    325                         RequestQueue* requests = mRequestQueues[REQUEST_TRACKING];
    326                         if (requests) {
    327                             delete requests;
    328                         }
    329                         trackingSession = mLocationAPI->startTracking(options);
    330                         LOC_LOGI("%s:%d] start new session: %d",
    331                                 __FUNCTION__, __LINE__, trackingSession);
    332                         requests = new RequestQueue(trackingSession);
    333                         requests->push(new StartTrackingRequest(*this));
    334                         mRequestQueues[REQUEST_TRACKING] = requests;
    335                     }
    336                 }
    337             } else if (sessionMode == SESSION_MODE_ON_FULL) {
    338                 if (sMode == SESSION_MODE_ON_FIX) {
    339                     // stop tracking
    340                     {
    341                         RequestQueue* requests = mRequestQueues[REQUEST_TRACKING];
    342                         if (requests) {
    343                             requests->push(new StopTrackingRequest(*this));
    344                             mLocationAPI->stopTracking(trackingSession);
    345                             trackingSession = 0;
    346                         }
    347                     }
    348                     // start batching
    349                     {
    350                         RequestQueue* requests = mRequestQueues[REQUEST_BATCHING];
    351                         if (requests) {
    352                             delete requests;
    353                         }
    354                         batchingSession = mLocationAPI->startBatching(options);
    355                         LOC_LOGI("%s:%d] start new session: %d",
    356                                 __FUNCTION__, __LINE__, batchingSession);
    357                         requests = new RequestQueue(batchingSession);
    358                         requests->push(new StartBatchingRequest(*this));
    359                         mRequestQueues[REQUEST_BATCHING] = requests;
    360                     }
    361                 } else if (sMode == SESSION_MODE_ON_FULL) {
    362                     RequestQueue* requests = mRequestQueues[REQUEST_BATCHING];
    363                     requests = mRequestQueues[REQUEST_BATCHING];
    364                     if (requests) {
    365                         requests->push(new UpdateBatchingOptionsRequest(*this));
    366                         mLocationAPI->updateBatchingOptions(batchingSession, options);
    367                     }
    368                 }
    369             }
    370 
    371             entity.trackingSession = trackingSession;
    372             entity.batchingSession = batchingSession;
    373             entity.sessionMode = sessionMode;
    374 
    375             retVal = LOCATION_ERROR_SUCCESS;
    376         } else {
    377             retVal = LOCATION_ERROR_ID_UNKNOWN;
    378             LOC_LOGE("%s:%d] session %d is not exist.", __FUNCTION__, __LINE__, id);
    379         }
    380 
    381         pthread_mutex_unlock(&mMutex);
    382     }
    383     return retVal;
    384 }
    385 
    386 void LocationAPIClientBase::locAPIGetBatchedLocations(size_t count)
    387 {
    388     if (mLocationAPI) {
    389         pthread_mutex_lock(&mMutex);
    390         uint32_t session = -1;
    391         RequestQueue* requests = mRequestQueues[REQUEST_BATCHING];
    392         if (requests) {
    393             session = requests->getSession();
    394             requests->push(new GetBatchedLocationsRequest(*this));
    395             mLocationAPI->getBatchedLocations(session, count);
    396         }
    397         pthread_mutex_unlock(&mMutex);
    398     }
    399 }
    400 
    401 uint32_t LocationAPIClientBase::locAPIAddGeofences(
    402         size_t count, uint32_t* ids, GeofenceOption* options, GeofenceInfo* data)
    403 {
    404     uint32_t retVal = LOCATION_ERROR_GENERAL_FAILURE;
    405     if (mLocationAPI) {
    406         pthread_mutex_lock(&mMutex);
    407         RequestQueue* requests = mRequestQueues[REQUEST_GEOFENCE];
    408         if (requests) {
    409             delete requests;
    410         }
    411         uint32_t* sessions = mLocationAPI->addGeofences(count, options, data);
    412         if (sessions) {
    413             LOC_LOGI("%s:%d] start new sessions: %p", __FUNCTION__, __LINE__, sessions);
    414             requests = new RequestQueue(-1);
    415             requests->push(new AddGeofencesRequest(*this));
    416             mRequestQueues[REQUEST_GEOFENCE] = requests;
    417 
    418             for (size_t i = 0; i < count; i++) {
    419                 mGeofenceBiDict.set(ids[i], sessions[i], options[i].breachTypeMask);
    420             }
    421             retVal = LOCATION_ERROR_SUCCESS;
    422         }
    423         pthread_mutex_unlock(&mMutex);
    424     }
    425 
    426     return retVal;
    427 }
    428 
    429 void LocationAPIClientBase::locAPIRemoveGeofences(size_t count, uint32_t* ids)
    430 {
    431     if (mLocationAPI) {
    432         uint32_t* sessions = (uint32_t*)malloc(sizeof(uint32_t) * count);
    433 
    434         pthread_mutex_lock(&mMutex);
    435         RequestQueue* requests = mRequestQueues[REQUEST_GEOFENCE];
    436         if (requests) {
    437             for (size_t i = 0; i < count; i++) {
    438                 sessions[i] = mGeofenceBiDict.getSession(ids[i]);
    439             }
    440             requests->push(new RemoveGeofencesRequest(*this));
    441             mLocationAPI->removeGeofences(count, sessions);
    442         }
    443         pthread_mutex_unlock(&mMutex);
    444 
    445         free(sessions);
    446     }
    447 }
    448 
    449 void LocationAPIClientBase::locAPIModifyGeofences(
    450         size_t count, uint32_t* ids, GeofenceOption* options)
    451 {
    452     if (mLocationAPI) {
    453         uint32_t* sessions = (uint32_t*)malloc(sizeof(uint32_t) * count);
    454 
    455         pthread_mutex_lock(&mMutex);
    456         RequestQueue* requests = mRequestQueues[REQUEST_GEOFENCE];
    457         if (requests) {
    458             for (size_t i = 0; i < count; i++) {
    459                 sessions[i] = mGeofenceBiDict.getSession(ids[i]);
    460                 mGeofenceBiDict.set(ids[i], sessions[i], options[i].breachTypeMask);
    461             }
    462             requests->push(new ModifyGeofencesRequest(*this));
    463             mLocationAPI->modifyGeofences(count, sessions, options);
    464         }
    465         pthread_mutex_unlock(&mMutex);
    466 
    467         free(sessions);
    468     }
    469 }
    470 
    471 void LocationAPIClientBase::locAPIPauseGeofences(size_t count, uint32_t* ids)
    472 {
    473     if (mLocationAPI) {
    474         uint32_t* sessions = (uint32_t*)malloc(sizeof(uint32_t) * count);
    475 
    476         pthread_mutex_lock(&mMutex);
    477         RequestQueue* requests = mRequestQueues[REQUEST_GEOFENCE];
    478         if (requests) {
    479             for (size_t i = 0; i < count; i++) {
    480                 sessions[i] = mGeofenceBiDict.getSession(ids[i]);
    481             }
    482             requests->push(new PauseGeofencesRequest(*this));
    483             mLocationAPI->pauseGeofences(count, sessions);
    484         }
    485         pthread_mutex_unlock(&mMutex);
    486 
    487         free(sessions);
    488     }
    489 }
    490 
    491 void LocationAPIClientBase::locAPIResumeGeofences(
    492         size_t count, uint32_t* ids, GeofenceBreachTypeMask* mask)
    493 {
    494     if (mLocationAPI) {
    495         uint32_t* sessions = (uint32_t*)malloc(sizeof(uint32_t) * count);
    496 
    497         pthread_mutex_lock(&mMutex);
    498         RequestQueue* requests = mRequestQueues[REQUEST_GEOFENCE];
    499         if (requests) {
    500             for (size_t i = 0; i < count; i++) {
    501                 sessions[i] = mGeofenceBiDict.getSession(ids[i]);
    502                 if (mask) {
    503                     mGeofenceBiDict.set(ids[i], sessions[i], mask[i]);
    504                 }
    505             }
    506             requests->push(new ResumeGeofencesRequest(*this));
    507             mLocationAPI->resumeGeofences(count, sessions);
    508         }
    509         pthread_mutex_unlock(&mMutex);
    510 
    511         free(sessions);
    512     }
    513 }
    514 
    515 void LocationAPIClientBase::locAPIRemoveAllGeofences()
    516 {
    517     if (mLocationAPI) {
    518         std::vector<uint32_t> sessionsVec = mGeofenceBiDict.getAllSessions();
    519         size_t count = sessionsVec.size();
    520         uint32_t* sessions = (uint32_t*)malloc(sizeof(uint32_t) * count);
    521 
    522         pthread_mutex_lock(&mMutex);
    523         RequestQueue* requests = mRequestQueues[REQUEST_GEOFENCE];
    524         if (requests) {
    525             for (size_t i = 0; i < count; i++) {
    526                 sessions[i] = sessionsVec[i];
    527             }
    528             requests->push(new RemoveGeofencesRequest(*this));
    529             mLocationAPI->removeGeofences(count, sessions);
    530         }
    531         pthread_mutex_unlock(&mMutex);
    532 
    533         free(sessions);
    534     }
    535 }
    536 
    537 void LocationAPIClientBase::locAPIGnssNiResponse(uint32_t id, GnssNiResponse response)
    538 {
    539     uint32_t session = 0;
    540     if (mLocationAPI) {
    541         pthread_mutex_lock(&mMutex);
    542         RequestQueue* requests = mRequestQueues[REQUEST_NIRESPONSE];
    543         if (requests) {
    544             delete requests;
    545         }
    546         uint32_t session = id;
    547         mLocationAPI->gnssNiResponse(id, response);
    548         LOC_LOGI("%s:%d] start new session: %d", __FUNCTION__, __LINE__, session);
    549         requests = new RequestQueue(session);
    550         requests->push(new GnssNiResponseRequest(*this));
    551         mRequestQueues[REQUEST_NIRESPONSE] = requests;
    552         pthread_mutex_unlock(&mMutex);
    553     }
    554 }
    555 
    556 uint32_t LocationAPIClientBase::locAPIGnssDeleteAidingData(GnssAidingData& data)
    557 {
    558     uint32_t retVal = LOCATION_ERROR_GENERAL_FAILURE;
    559     if (mLocationControlAPI) {
    560         pthread_mutex_lock(&mMutex);
    561         RequestQueue* requests = mRequestQueues[REQUEST_DELETEAIDINGDATA];
    562         if (requests) {
    563             delete requests;
    564         }
    565         uint32_t session = mLocationControlAPI->gnssDeleteAidingData(data);
    566         LOC_LOGI("%s:%d] start new session: %d", __FUNCTION__, __LINE__, session);
    567         requests = new RequestQueue(session);
    568         requests->push(new GnssDeleteAidingDataRequest(*this));
    569         mRequestQueues[REQUEST_DELETEAIDINGDATA] = requests;
    570         pthread_mutex_unlock(&mMutex);
    571 
    572         retVal = LOCATION_ERROR_SUCCESS;
    573     }
    574 
    575     return retVal;
    576 }
    577 
    578 uint32_t LocationAPIClientBase::locAPIEnable(LocationTechnologyType techType)
    579 {
    580     uint32_t retVal = LOCATION_ERROR_GENERAL_FAILURE;
    581     if (mLocationControlAPI) {
    582         pthread_mutex_lock(&mMutex);
    583         RequestQueue* requests = mRequestQueues[REQUEST_CONTROL];
    584         if (requests) {
    585             delete requests;
    586         }
    587         uint32_t session = mLocationControlAPI->enable(techType);
    588         LOC_LOGI("%s:%d] start new session: %d", __FUNCTION__, __LINE__, session);
    589         requests = new RequestQueue(session);
    590         requests->push(new EnableRequest(*this));
    591         mRequestQueues[REQUEST_CONTROL] = requests;
    592         pthread_mutex_unlock(&mMutex);
    593 
    594         retVal = LOCATION_ERROR_SUCCESS;
    595     }
    596 
    597     return retVal;
    598 }
    599 
    600 void LocationAPIClientBase::locAPIDisable()
    601 {
    602     if (mLocationControlAPI) {
    603         pthread_mutex_lock(&mMutex);
    604         uint32_t session = -1;
    605         RequestQueue* requests = mRequestQueues[REQUEST_CONTROL];
    606         if (requests) {
    607             session = requests->getSession();
    608             requests->push(new DisableRequest(*this));
    609             mLocationControlAPI->disable(session);
    610         }
    611         pthread_mutex_unlock(&mMutex);
    612     }
    613 }
    614 
    615 uint32_t LocationAPIClientBase::locAPIGnssUpdateConfig(GnssConfig config)
    616 {
    617     uint32_t retVal = LOCATION_ERROR_GENERAL_FAILURE;
    618     if (memcmp(&mConfig, &config, sizeof(GnssConfig)) == 0) {
    619         LOC_LOGE("%s:%d] GnssConfig is identical to previous call", __FUNCTION__, __LINE__);
    620         return retVal;
    621     }
    622 
    623     if (mLocationControlAPI) {
    624         pthread_mutex_lock(&mMutex);
    625 
    626         memcpy(&mConfig, &config, sizeof(GnssConfig));
    627 
    628         uint32_t session = -1;
    629         RequestQueue* requests = mRequestQueues[REQUEST_CONTROL];
    630         if (requests) {
    631             session = requests->getSession();
    632             requests->push(new GnssUpdateConfigRequest(*this));
    633             uint32_t* idArray = mLocationControlAPI->gnssUpdateConfig(config);
    634             LOC_LOGV("%s:%d] gnssUpdateConfig return array: %p", __FUNCTION__, __LINE__, idArray);
    635         }
    636         pthread_mutex_unlock(&mMutex);
    637 
    638         retVal = LOCATION_ERROR_SUCCESS;
    639     }
    640     return retVal;
    641 }
    642 
    643 void LocationAPIClientBase::beforeGeofenceBreachCb(
    644         GeofenceBreachNotification geofenceBreachNotification)
    645 {
    646     if (mGeofenceBreachCallback == nullptr)
    647         return;
    648     uint32_t* ids = (uint32_t*)malloc(sizeof(uint32_t) * geofenceBreachNotification.count);
    649     uint32_t* backup = geofenceBreachNotification.ids;
    650     size_t n = geofenceBreachNotification.count;
    651 
    652     size_t count = 0;
    653     for (size_t i = 0; i < n; i++) {
    654         uint32_t id = mGeofenceBiDict.getId(geofenceBreachNotification.ids[i]);
    655         GeofenceBreachTypeMask type = mGeofenceBiDict.getType(geofenceBreachNotification.ids[i]);
    656         if ((geofenceBreachNotification.type == GEOFENCE_BREACH_ENTER &&
    657             (type & GEOFENCE_BREACH_ENTER_BIT)) ||
    658             (geofenceBreachNotification.type == GEOFENCE_BREACH_EXIT &&
    659             (type & GEOFENCE_BREACH_EXIT_BIT))
    660            ) {
    661             ids[count] = id;
    662             count++;
    663         }
    664     }
    665     geofenceBreachNotification.count = count;
    666     geofenceBreachNotification.ids = ids;
    667     mGeofenceBreachCallback(geofenceBreachNotification);
    668 
    669     // restore ids
    670     geofenceBreachNotification.ids = backup;
    671     geofenceBreachNotification.count = n;
    672     free(ids);
    673 }
    674 
    675 void LocationAPIClientBase::onResponseCb(LocationError error, uint32_t id)
    676 {
    677     if (error != LOCATION_ERROR_SUCCESS) {
    678         LOC_LOGE("%s:%d] ERROR: %d ID: %d", __FUNCTION__, __LINE__, error, id);
    679     } else {
    680         LOC_LOGV("%s:%d] error: %d id: %d", __FUNCTION__, __LINE__, error, id);
    681     }
    682     LocationAPIRequest* request = getRequestBySession(id);
    683     if (request) {
    684         request->onResponse(error);
    685         delete request;
    686     }
    687 }
    688 
    689 void LocationAPIClientBase::onCollectiveResponseCb(
    690         size_t count, LocationError* errors, uint32_t* ids)
    691 {
    692     for (size_t i = 0; i < count; i++) {
    693         if (errors[i] != LOCATION_ERROR_SUCCESS) {
    694             LOC_LOGE("%s:%d] ERROR: %d ID: %d", __FUNCTION__, __LINE__, errors[i], ids[i]);
    695         } else {
    696             LOC_LOGV("%s:%d] error: %d id: %d", __FUNCTION__, __LINE__, errors[i], ids[i]);
    697         }
    698     }
    699     LocationAPIRequest* request = nullptr;
    700     if (count > 0 && ids)
    701         request = getRequestBySession(ids[0]);
    702     if (!request)
    703         request = getGeofencesRequest();
    704     if (request) {
    705         request->onCollectiveResponse(count, errors, ids);
    706         delete request;
    707     }
    708 }
    709 
    710 void LocationAPIClientBase::onCtrlResponseCb(LocationError error, uint32_t id)
    711 {
    712     if (error != LOCATION_ERROR_SUCCESS) {
    713         LOC_LOGE("%s:%d] ERROR: %d ID: %d", __FUNCTION__, __LINE__, error, id);
    714     } else {
    715         LOC_LOGV("%s:%d] error: %d id: %d", __FUNCTION__, __LINE__, error, id);
    716     }
    717     LocationAPIRequest* request = getRequestBySession(id);
    718     if (request) {
    719         request->onResponse(error);
    720         delete request;
    721     }
    722 }
    723 
    724 void LocationAPIClientBase::onCtrlCollectiveResponseCb(
    725         size_t count, LocationError* errors, uint32_t* ids)
    726 {
    727     for (size_t i = 0; i < count; i++) {
    728         if (errors[i] != LOCATION_ERROR_SUCCESS) {
    729             LOC_LOGE("%s:%d] ERROR: %d ID: %d", __FUNCTION__, __LINE__, errors[i], ids[i]);
    730         } else {
    731             LOC_LOGV("%s:%d] error: %d id: %d", __FUNCTION__, __LINE__, errors[i], ids[i]);
    732         }
    733     }
    734     LocationAPIRequest* request = nullptr;
    735     if (count > 0 && ids)
    736         request = getRequestBySession(ids[0]);
    737     if (request) {
    738         request->onCollectiveResponse(count, errors, ids);
    739         delete request;
    740     }
    741 }
    742 
    743 LocationAPIClientBase::LocationAPIRequest*
    744 LocationAPIClientBase::getRequestBySession(uint32_t session)
    745 {
    746     pthread_mutex_lock(&mMutex);
    747     LocationAPIRequest* request = nullptr;
    748     for (int i = 0; i < REQUEST_MAX; i++) {
    749         if (i != REQUEST_GEOFENCE &&
    750                 mRequestQueues[i] &&
    751                 mRequestQueues[i]->getSession() == session) {
    752             request = mRequestQueues[i]->pop();
    753             break;
    754         }
    755     }
    756     pthread_mutex_unlock(&mMutex);
    757     return request;
    758 }
    759 
    760 LocationAPIClientBase::LocationAPIRequest*
    761 LocationAPIClientBase::getGeofencesRequest()
    762 {
    763     pthread_mutex_lock(&mMutex);
    764     LocationAPIRequest* request = nullptr;
    765     if (mRequestQueues[REQUEST_GEOFENCE]) {
    766         request = mRequestQueues[REQUEST_GEOFENCE]->pop();
    767     }
    768     pthread_mutex_unlock(&mMutex);
    769     return request;
    770 }
    771