Split control apis to a separate class

Move control apis to LocationAPIControlClient.
There should be only one instance of it per process.

Change-Id: I5969e6b3ad45f3fc5bfe4f4cd543a077c540c3ea
CRs-Fixed: 2064389

android/AGnssRil.cpp

@@ -47,7 +47,7 @@ AGnssRil::~AGnssRil() {
     ENTRY_LOG_CALLFLOW();
 }
 
-Return<bool> AGnssRil::updateNetworkState(bool connected, NetworkType type, bool roaming) {
+Return<bool> AGnssRil::updateNetworkState(bool connected, NetworkType type, bool /*roaming*/) {
     ENTRY_LOG_CALLFLOW();
 
     // for XTRA

android/Gnss.cpp

@@ -120,7 +120,7 @@ Return<bool> Gnss::setCallback(const sp<IGnssCallback>& callback)  {
     GnssAPIClient* api = getApi();
     if (api != nullptr) {
         api->gnssUpdateCallbacks(mGnssCbIface, mGnssNiCbIface);
-        api->locAPIEnable(LOCATION_TECHNOLOGY_TYPE_GNSS);
+        api->gnssEnable(LOCATION_TECHNOLOGY_TYPE_GNSS);
         api->requestCapabilities();
     }
     return true;
@@ -140,7 +140,7 @@ Return<bool> Gnss::updateConfiguration(GnssConfig& gnssConfig) {
     ENTRY_LOG_CALLFLOW();
     GnssAPIClient* api = getApi();
     if (api) {
-        api->locAPIGnssUpdateConfig(gnssConfig);
+        api->gnssConfigurationUpdate(gnssConfig);
     } else if (gnssConfig.flags != 0) {
         // api is not ready yet, update mPendingConfig with gnssConfig
         mPendingConfig.size = sizeof(GnssConfig);
@@ -220,7 +220,7 @@ Return<void> Gnss::cleanup()  {
     ENTRY_LOG_CALLFLOW();
 
     if (mApi != nullptr) {
-        mApi->locAPIDisable();
+        mApi->gnssDisable();
     }
 
     return Void();

android/location_api/GnssAPIClient.cpp

@@ -50,6 +50,7 @@ GnssAPIClient::GnssAPIClient(const sp<IGnssCallback>& gpsCb,
     LocationAPIClientBase(),
     mGnssCbIface(nullptr),
     mGnssNiCbIface(nullptr),
+    mControlClient(new LocationAPIControlClient()),
     mLocationCapabilitiesMask(0),
     mLocationCapabilitiesCached(false)
 {
@@ -68,6 +69,10 @@ GnssAPIClient::GnssAPIClient(const sp<IGnssCallback>& gpsCb,
 GnssAPIClient::~GnssAPIClient()
 {
     LOC_LOGD("%s]: ()", __FUNCTION__);
+    if (mControlClient) {
+        delete mControlClient;
+        mControlClient = nullptr;
+    }
 }
 
 // for GpsInterface
@@ -142,9 +147,56 @@ bool GnssAPIClient::gnssStop()
     return retVal;
 }
 
+bool GnssAPIClient::gnssSetPositionMode(IGnss::GnssPositionMode mode,
+        IGnss::GnssPositionRecurrence recurrence, uint32_t minIntervalMs,
+        uint32_t preferredAccuracyMeters, uint32_t preferredTimeMs)
+{
+    LOC_LOGD("%s]: (%d %d %d %d %d)", __FUNCTION__,
+            (int)mode, recurrence, minIntervalMs, preferredAccuracyMeters, preferredTimeMs);
+    bool retVal = true;
+    memset(&mLocationOptions, 0, sizeof(LocationOptions));
+    mLocationOptions.size = sizeof(LocationOptions);
+    mLocationOptions.minInterval = minIntervalMs;
+    mLocationOptions.minDistance = preferredAccuracyMeters;
+    if (mode == IGnss::GnssPositionMode::STANDALONE)
+        mLocationOptions.mode = GNSS_SUPL_MODE_STANDALONE;
+    else if (mode == IGnss::GnssPositionMode::MS_BASED)
+        mLocationOptions.mode = GNSS_SUPL_MODE_MSB;
+    else if (mode ==  IGnss::GnssPositionMode::MS_ASSISTED)
+        mLocationOptions.mode = GNSS_SUPL_MODE_MSA;
+    else {
+        LOC_LOGD("%s]: invalid GnssPositionMode: %d", __FUNCTION__, mode);
+        retVal = false;
+    }
+    return retVal;
+}
+
+// for GpsNiInterface
+void GnssAPIClient::gnssNiRespond(int32_t notifId,
+        IGnssNiCallback::GnssUserResponseType userResponse)
+{
+    LOC_LOGD("%s]: (%d %d)", __FUNCTION__, notifId, static_cast<int>(userResponse));
+    GnssNiResponse data = GNSS_NI_RESPONSE_IGNORE;
+    if (userResponse == IGnssNiCallback::GnssUserResponseType::RESPONSE_ACCEPT)
+        data = GNSS_NI_RESPONSE_ACCEPT;
+    else if (userResponse == IGnssNiCallback::GnssUserResponseType::RESPONSE_DENY)
+        data = GNSS_NI_RESPONSE_DENY;
+    else if (userResponse == IGnssNiCallback::GnssUserResponseType::RESPONSE_NORESP)
+        data = GNSS_NI_RESPONSE_NO_RESPONSE;
+    else {
+        LOC_LOGD("%s]: invalid GnssUserResponseType: %d", __FUNCTION__, userResponse);
+        return;
+    }
+    locAPIGnssNiResponse(notifId, data);
+}
+
+// these apis using LocationAPIControlClient
 void GnssAPIClient::gnssDeleteAidingData(IGnss::GnssAidingData aidingDataFlags)
 {
     LOC_LOGD("%s]: (%02hx)", __FUNCTION__, aidingDataFlags);
+    if (mControlClient == nullptr) {
+        return;
+    }
     GnssAidingData data;
     memset(&data, 0, sizeof (GnssAidingData));
     data.sv.svTypeMask = GNSS_AIDING_DATA_SV_TYPE_GPS_BIT |
@@ -181,50 +233,34 @@ void GnssAPIClient::gnssDeleteAidingData(IGnss::GnssAidingData aidingDataFlags)
         if (aidingDataFlags & IGnss::GnssAidingData::DELETE_CELLDB_INFO)
             data.common.mask |= GNSS_AIDING_DATA_COMMON_CELLDB_BIT;
     }
-    locAPIGnssDeleteAidingData(data);
+    mControlClient->locAPIGnssDeleteAidingData(data);
 }
 
-bool GnssAPIClient::gnssSetPositionMode(IGnss::GnssPositionMode mode,
+void GnssAPIClient::gnssEnable(LocationTechnologyType techType)
-        IGnss::GnssPositionRecurrence recurrence, uint32_t minIntervalMs,
-        uint32_t preferredAccuracyMeters, uint32_t preferredTimeMs)
 {
-    LOC_LOGD("%s]: (%d %d %d %d %d)", __FUNCTION__,
+    LOC_LOGD("%s]: (%0d)", __FUNCTION__, techType);
-            (int)mode, recurrence, minIntervalMs, preferredAccuracyMeters, preferredTimeMs);
+    if (mControlClient == nullptr) {
-    bool retVal = true;
+        return;
-    memset(&mLocationOptions, 0, sizeof(LocationOptions));
+    }
-    mLocationOptions.size = sizeof(LocationOptions);
+    mControlClient->locAPIEnable(techType);
-    mLocationOptions.minInterval = minIntervalMs;
-    mLocationOptions.minDistance = preferredAccuracyMeters;
-    if (mode == IGnss::GnssPositionMode::STANDALONE)
-        mLocationOptions.mode = GNSS_SUPL_MODE_STANDALONE;
-    else if (mode == IGnss::GnssPositionMode::MS_BASED)
-        mLocationOptions.mode = GNSS_SUPL_MODE_MSB;
-    else if (mode ==  IGnss::GnssPositionMode::MS_ASSISTED)
-        mLocationOptions.mode = GNSS_SUPL_MODE_MSA;
-    locAPIUpdateTrackingOptions(mLocationOptions);
-    return retVal;
 }
 
-// for GpsNiInterface
+void GnssAPIClient::gnssDisable()
-void GnssAPIClient::gnssNiRespond(int32_t notifId,
-        IGnssNiCallback::GnssUserResponseType userResponse)
 {
-    LOC_LOGD("%s]: (%d %d)", __FUNCTION__, notifId, static_cast<int>(userResponse));
+    LOC_LOGD("%s]: ()", __FUNCTION__);
-    GnssNiResponse data = GNSS_NI_RESPONSE_IGNORE;
+    if (mControlClient == nullptr) {
-    if (userResponse == IGnssNiCallback::GnssUserResponseType::RESPONSE_ACCEPT)
+        return;
-        data = GNSS_NI_RESPONSE_ACCEPT;
+    }
-    else if (userResponse == IGnssNiCallback::GnssUserResponseType::RESPONSE_DENY)
+    mControlClient->locAPIDisable();
-        data = GNSS_NI_RESPONSE_DENY;
-    else if (userResponse == IGnssNiCallback::GnssUserResponseType::RESPONSE_NORESP)
-        data = GNSS_NI_RESPONSE_NO_RESPONSE;
-    locAPIGnssNiResponse(notifId, data);
 }
 
-// for GnssConfigurationInterface
 void GnssAPIClient::gnssConfigurationUpdate(const GnssConfig& gnssConfig)
 {
     LOC_LOGD("%s]: (%02x)", __FUNCTION__, gnssConfig.flags);
-    locAPIGnssUpdateConfig(gnssConfig);
+    if (mControlClient == nullptr) {
+        return;
+    }
+    mControlClient->locAPIGnssUpdateConfig(gnssConfig);
 }
 
 void GnssAPIClient::requestCapabilities() {
@@ -385,7 +421,7 @@ void GnssAPIClient::onGnssNmeaCb(GnssNmeaNotification gnssNmeaNotification)
         auto r = mGnssCbIface->gnssNmeaCb(
             static_cast<GnssUtcTime>(gnssNmeaNotification.timestamp), nmeaString);
         if (!r.isOk()) {
-            LOC_LOGE("%s] Error from gnssNmeaCb nmea=%s length=%u description=%s", __func__,
+            LOC_LOGE("%s] Error from gnssNmeaCb nmea=%s length=%zu description=%s", __func__,
                 gnssNmeaNotification.nmea, gnssNmeaNotification.length, r.description().c_str());
         }
     }

android/location_api/GnssAPIClient.h

@@ -58,7 +58,6 @@ public:
             const sp<IGnssNiCallback>& niCb);
     bool gnssStart();
     bool gnssStop();
-    void gnssDeleteAidingData(IGnss::GnssAidingData aidingDataFlags);
     bool gnssSetPositionMode(IGnss::GnssPositionMode mode,
             IGnss::GnssPositionRecurrence recurrence,
             uint32_t minIntervalMs,
@@ -68,7 +67,10 @@ public:
     // for GpsNiInterface
     void gnssNiRespond(int32_t notifId, IGnssNiCallback::GnssUserResponseType userResponse);
 
-    // for GnssConfigurationInterface
+    // these apis using LocationAPIControlClient
+    void gnssDeleteAidingData(IGnss::GnssAidingData aidingDataFlags);
+    void gnssEnable(LocationTechnologyType techType);
+    void gnssDisable();
     void gnssConfigurationUpdate(const GnssConfig& gnssConfig);
 
     inline LocationCapabilitiesMask gnssGetCapabilities() const {
@@ -90,6 +92,7 @@ private:
     sp<IGnssCallback> mGnssCbIface;
     sp<IGnssNiCallback> mGnssNiCbIface;
 
+    LocationAPIControlClient* mControlClient;
     LocationCapabilitiesMask mLocationCapabilitiesMask;
     bool mLocationCapabilitiesCached;
 

location/LocationAPIClientBase.cpp

@@ -37,12 +37,192 @@
 #define GEOFENCE_SESSION_ID 0xFFFFFFFF
 #define CONFIG_SESSION_ID 0xFFFFFFFF
 
+// LocationAPIControlClient
+LocationAPIControlClient::LocationAPIControlClient() :
+    mEnabled(false)
+{
+    pthread_mutex_init(&mMutex, nullptr);
+
+    for (int i = 0; i < CTRL_REQUEST_MAX; i++) {
+        mRequestQueues[i].reset(0);
+    }
+
+    memset(&mConfig, 0, sizeof(GnssConfig));
+
+    LocationControlCallbacks locationControlCallbacks;
+    locationControlCallbacks.size = sizeof(LocationControlCallbacks);
+
+    locationControlCallbacks.responseCb =
+        [this](LocationError error, uint32_t id) {
+            onCtrlResponseCb(error, id);
+        };
+    locationControlCallbacks.collectiveResponseCb =
+        [this](size_t count, LocationError* errors, uint32_t* ids) {
+            onCtrlCollectiveResponseCb(count, errors, ids);
+        };
+
+    mLocationControlAPI = LocationControlAPI::createInstance(locationControlCallbacks);
+}
+
+LocationAPIControlClient::~LocationAPIControlClient()
+{
+    pthread_mutex_lock(&mMutex);
+
+    if (mLocationControlAPI) {
+        mLocationControlAPI->destroy();
+        mLocationControlAPI = nullptr;
+    }
+
+    for (int i = 0; i < CTRL_REQUEST_MAX; i++) {
+        mRequestQueues[i].reset(0);
+    }
+
+    pthread_mutex_unlock(&mMutex);
+
+    pthread_mutex_destroy(&mMutex);
+}
+
+uint32_t LocationAPIControlClient::locAPIGnssDeleteAidingData(GnssAidingData& data)
+{
+    uint32_t retVal = LOCATION_ERROR_GENERAL_FAILURE;
+    pthread_mutex_lock(&mMutex);
+    if (mLocationControlAPI) {
+        uint32_t session = mLocationControlAPI->gnssDeleteAidingData(data);
+        LOC_LOGI("%s:%d] start new session: %d", __FUNCTION__, __LINE__, session);
+        mRequestQueues[CTRL_REQUEST_DELETEAIDINGDATA].reset(session);
+        mRequestQueues[CTRL_REQUEST_DELETEAIDINGDATA].push(new GnssDeleteAidingDataRequest(*this));
+
+        retVal = LOCATION_ERROR_SUCCESS;
+    }
+    pthread_mutex_unlock(&mMutex);
+
+    return retVal;
+}
+
+uint32_t LocationAPIControlClient::locAPIEnable(LocationTechnologyType techType)
+{
+    uint32_t retVal = LOCATION_ERROR_GENERAL_FAILURE;
+    pthread_mutex_lock(&mMutex);
+    if (mEnabled) {
+        // just return success if already enabled
+        retVal = LOCATION_ERROR_SUCCESS;
+    } else if (mLocationControlAPI) {
+        uint32_t session = mLocationControlAPI->enable(techType);
+        LOC_LOGI("%s:%d] start new session: %d", __FUNCTION__, __LINE__, session);
+        mRequestQueues[CTRL_REQUEST_CONTROL].reset(session);
+        mRequestQueues[CTRL_REQUEST_CONTROL].push(new EnableRequest(*this));
+        retVal = LOCATION_ERROR_SUCCESS;
+        mEnabled = true;
+    } else {
+        LOC_LOGE("%s:%d] failed.", __FUNCTION__, __LINE__);
+    }
+    pthread_mutex_unlock(&mMutex);
+
+    return retVal;
+}
+
+void LocationAPIControlClient::locAPIDisable()
+{
+    pthread_mutex_lock(&mMutex);
+    if (mEnabled && mLocationControlAPI) {
+        uint32_t session = 0;
+        session = mRequestQueues[CTRL_REQUEST_CONTROL].getSession();
+        if (session > 0) {
+            mRequestQueues[CTRL_REQUEST_CONTROL].push(new DisableRequest(*this));
+            mLocationControlAPI->disable(session);
+            mEnabled = false;
+        } else {
+            LOC_LOGE("%s:%d] invalid session: %d.", __FUNCTION__, __LINE__, session);
+        }
+    }
+    pthread_mutex_unlock(&mMutex);
+}
+
+uint32_t LocationAPIControlClient::locAPIGnssUpdateConfig(GnssConfig config)
+{
+    uint32_t retVal = LOCATION_ERROR_GENERAL_FAILURE;
+    if (memcmp(&mConfig, &config, sizeof(GnssConfig)) == 0) {
+        LOC_LOGV("%s:%d] GnssConfig is identical to previous call", __FUNCTION__, __LINE__);
+        retVal = LOCATION_ERROR_SUCCESS;
+        return retVal;
+    }
+
+    pthread_mutex_lock(&mMutex);
+    if (mLocationControlAPI) {
+
+        memcpy(&mConfig, &config, sizeof(GnssConfig));
+
+        uint32_t session = 0;
+        uint32_t* idArray = mLocationControlAPI->gnssUpdateConfig(config);
+        LOC_LOGV("%s:%d] gnssUpdateConfig return array: %p", __FUNCTION__, __LINE__, idArray);
+        if (idArray != nullptr) {
+            if (mRequestQueues[CTRL_REQUEST_CONFIG].getSession() != CONFIG_SESSION_ID) {
+                mRequestQueues[CTRL_REQUEST_CONFIG].reset(CONFIG_SESSION_ID);
+            }
+            mRequestQueues[CTRL_REQUEST_CONFIG].push(new GnssUpdateConfigRequest(*this));
+            retVal = LOCATION_ERROR_SUCCESS;
+        }
+    }
+    pthread_mutex_unlock(&mMutex);
+    return retVal;
+}
+
+void LocationAPIControlClient::onCtrlResponseCb(LocationError error, uint32_t id)
+{
+    if (error != LOCATION_ERROR_SUCCESS) {
+        LOC_LOGE("%s:%d] ERROR: %d ID: %d", __FUNCTION__, __LINE__, error, id);
+    } else {
+        LOC_LOGV("%s:%d] SUCCESS: %d id: %d", __FUNCTION__, __LINE__, error, id);
+    }
+    LocationAPIRequest* request = getRequestBySession(id);
+    if (request) {
+        request->onResponse(error);
+        delete request;
+    }
+}
+
+void LocationAPIControlClient::onCtrlCollectiveResponseCb(
+        size_t count, LocationError* errors, uint32_t* ids)
+{
+    for (size_t i = 0; i < count; i++) {
+        if (errors[i] != LOCATION_ERROR_SUCCESS) {
+            LOC_LOGE("%s:%d] ERROR: %d ID: %d", __FUNCTION__, __LINE__, errors[i], ids[i]);
+        } else {
+            LOC_LOGV("%s:%d] SUCCESS: %d id: %d", __FUNCTION__, __LINE__, errors[i], ids[i]);
+        }
+    }
+    LocationAPIRequest* request = nullptr;
+    pthread_mutex_lock(&mMutex);
+    if (mRequestQueues[CTRL_REQUEST_CONFIG].getSession() == CONFIG_SESSION_ID) {
+        request = mRequestQueues[CTRL_REQUEST_CONFIG].pop();
+    }
+    pthread_mutex_unlock(&mMutex);
+    if (request) {
+        request->onCollectiveResponse(count, errors, ids);
+        delete request;
+    }
+}
+
+LocationAPIRequest* LocationAPIControlClient::getRequestBySession(uint32_t session)
+{
+    pthread_mutex_lock(&mMutex);
+    LocationAPIRequest* request = nullptr;
+    for (int i = 0; i < CTRL_REQUEST_MAX; i++) {
+        if (i != CTRL_REQUEST_CONFIG &&
+                mRequestQueues[i].getSession() == session) {
+            request = mRequestQueues[i].pop();
+            break;
+        }
+    }
+    pthread_mutex_unlock(&mMutex);
+    return request;
+}
+
+// LocationAPIClientBase
 LocationAPIClientBase::LocationAPIClientBase() :
     mGeofenceBreachCallback(nullptr),
     mLocationAPI(nullptr),
-    mLocationControlAPI(nullptr),
+    mBatchSize(-1)
-    mBatchSize(-1),
-    mEnabled(false)
 {
 
     // use recursive mutex, in case callback come from the same thread
@@ -54,8 +234,6 @@ LocationAPIClientBase::LocationAPIClientBase() :
     for (int i = 0; i < REQUEST_MAX; i++) {
         mRequestQueues[i].reset(0);
     }
-
-    memset(&mConfig, 0, sizeof(GnssConfig));
 }
 
 void LocationAPIClientBase::locAPISetCallbacks(LocationCallbacks& locationCallbacks)
@@ -88,22 +266,6 @@ void LocationAPIClientBase::locAPISetCallbacks(LocationCallbacks& locationCallba
         mLocationAPI->updateCallbacks(locationCallbacks);
     }
 
-    if (mLocationControlAPI == nullptr) {
-        LocationControlCallbacks locationControlCallbacks;
-        locationControlCallbacks.size = sizeof(LocationControlCallbacks);
-
-        locationControlCallbacks.responseCb =
-            [this](LocationError error, uint32_t id) {
-                onCtrlResponseCb(error, id);
-            };
-        locationControlCallbacks.collectiveResponseCb =
-            [this](size_t count, LocationError* errors, uint32_t* ids) {
-                onCtrlCollectiveResponseCb(count, errors, ids);
-            };
-
-        mLocationControlAPI = LocationControlAPI::createInstance(locationControlCallbacks);
-    }
-
     pthread_mutex_unlock(&mMutex);
 }
 
@@ -117,10 +279,6 @@ LocationAPIClientBase::~LocationAPIClientBase()
         mLocationAPI->destroy();
         mLocationAPI = nullptr;
     }
-    if (mLocationControlAPI) {
-        mLocationControlAPI->destroy();
-        mLocationControlAPI = nullptr;
-    }
 
     for (int i = 0; i < REQUEST_MAX; i++) {
         mRequestQueues[i].reset(0);
@@ -581,89 +739,6 @@ void LocationAPIClientBase::locAPIGnssNiResponse(uint32_t id, GnssNiResponse res
     pthread_mutex_unlock(&mMutex);
 }
 
-uint32_t LocationAPIClientBase::locAPIGnssDeleteAidingData(GnssAidingData& data)
-{
-    uint32_t retVal = LOCATION_ERROR_GENERAL_FAILURE;
-    pthread_mutex_lock(&mMutex);
-    if (mLocationControlAPI) {
-        uint32_t session = mLocationControlAPI->gnssDeleteAidingData(data);
-        LOC_LOGI("%s:%d] start new session: %d", __FUNCTION__, __LINE__, session);
-        mRequestQueues[REQUEST_DELETEAIDINGDATA].reset(session);
-        mRequestQueues[REQUEST_DELETEAIDINGDATA].push(new GnssDeleteAidingDataRequest(*this));
-
-        retVal = LOCATION_ERROR_SUCCESS;
-    }
-    pthread_mutex_unlock(&mMutex);
-
-    return retVal;
-}
-
-uint32_t LocationAPIClientBase::locAPIEnable(LocationTechnologyType techType)
-{
-    uint32_t retVal = LOCATION_ERROR_GENERAL_FAILURE;
-    pthread_mutex_lock(&mMutex);
-    if (mEnabled) {
-        // just return success if already enabled
-        retVal = LOCATION_ERROR_SUCCESS;
-    } else if (mLocationControlAPI) {
-        uint32_t session = mLocationControlAPI->enable(techType);
-        LOC_LOGI("%s:%d] start new session: %d", __FUNCTION__, __LINE__, session);
-        mRequestQueues[REQUEST_CONTROL].reset(session);
-        mRequestQueues[REQUEST_CONTROL].push(new EnableRequest(*this));
-        retVal = LOCATION_ERROR_SUCCESS;
-        mEnabled = true;
-    }
-    pthread_mutex_unlock(&mMutex);
-
-    return retVal;
-}
-
-void LocationAPIClientBase::locAPIDisable()
-{
-    pthread_mutex_lock(&mMutex);
-    if (mEnabled && mLocationControlAPI) {
-        uint32_t session = 0;
-        session = mRequestQueues[REQUEST_CONTROL].getSession();
-        if (session > 0) {
-            mRequestQueues[REQUEST_CONTROL].push(new DisableRequest(*this));
-            mLocationControlAPI->disable(session);
-            mEnabled = false;
-        } else {
-            LOC_LOGE("%s:%d] invalid session: %d.", __FUNCTION__, __LINE__, session);
-        }
-    }
-    pthread_mutex_unlock(&mMutex);
-}
-
-uint32_t LocationAPIClientBase::locAPIGnssUpdateConfig(GnssConfig config)
-{
-    uint32_t retVal = LOCATION_ERROR_GENERAL_FAILURE;
-    if (memcmp(&mConfig, &config, sizeof(GnssConfig)) == 0) {
-        LOC_LOGV("%s:%d] GnssConfig is identical to previous call", __FUNCTION__, __LINE__);
-        retVal = LOCATION_ERROR_SUCCESS;
-        return retVal;
-    }
-
-    pthread_mutex_lock(&mMutex);
-    if (mLocationControlAPI) {
-
-        memcpy(&mConfig, &config, sizeof(GnssConfig));
-
-        uint32_t session = 0;
-        uint32_t* idArray = mLocationControlAPI->gnssUpdateConfig(config);
-        LOC_LOGV("%s:%d] gnssUpdateConfig return array: %p", __FUNCTION__, __LINE__, idArray);
-        if (idArray != nullptr) {
-            if (mRequestQueues[REQUEST_CONFIG].getSession() != CONFIG_SESSION_ID) {
-                mRequestQueues[REQUEST_CONFIG].reset(CONFIG_SESSION_ID);
-            }
-            mRequestQueues[REQUEST_CONFIG].push(new GnssUpdateConfigRequest(*this));
-            retVal = LOCATION_ERROR_SUCCESS;
-        }
-    }
-    pthread_mutex_unlock(&mMutex);
-    return retVal;
-}
-
 void LocationAPIClientBase::beforeGeofenceBreachCb(
         GeofenceBreachNotification geofenceBreachNotification)
 {
@@ -712,7 +787,7 @@ void LocationAPIClientBase::onResponseCb(LocationError error, uint32_t id)
     if (error != LOCATION_ERROR_SUCCESS) {
         LOC_LOGE("%s:%d] ERROR: %d ID: %d", __FUNCTION__, __LINE__, error, id);
     } else {
-        LOC_LOGV("%s:%d] error: %d id: %d", __FUNCTION__, __LINE__, error, id);
+        LOC_LOGV("%s:%d] SUCCESS: %d id: %d", __FUNCTION__, __LINE__, error, id);
     }
     LocationAPIRequest* request = getRequestBySession(id);
     if (request) {
@@ -728,7 +803,7 @@ void LocationAPIClientBase::onCollectiveResponseCb(
         if (errors[i] != LOCATION_ERROR_SUCCESS) {
             LOC_LOGE("%s:%d] ERROR: %d ID: %d", __FUNCTION__, __LINE__, errors[i], ids[i]);
         } else {
-            LOC_LOGV("%s:%d] error: %d id: %d", __FUNCTION__, __LINE__, errors[i], ids[i]);
+            LOC_LOGV("%s:%d] SUCCESS: %d id: %d", __FUNCTION__, __LINE__, errors[i], ids[i]);
         }
     }
     LocationAPIRequest* request = nullptr;
@@ -743,50 +818,12 @@ void LocationAPIClientBase::onCollectiveResponseCb(
     }
 }
 
-void LocationAPIClientBase::onCtrlResponseCb(LocationError error, uint32_t id)
+LocationAPIRequest* LocationAPIClientBase::getRequestBySession(uint32_t session)
-{
-    if (error != LOCATION_ERROR_SUCCESS) {
-        LOC_LOGE("%s:%d] ERROR: %d ID: %d", __FUNCTION__, __LINE__, error, id);
-    } else {
-        LOC_LOGV("%s:%d] error: %d id: %d", __FUNCTION__, __LINE__, error, id);
-    }
-    LocationAPIRequest* request = getRequestBySession(id);
-    if (request) {
-        request->onResponse(error);
-        delete request;
-    }
-}
-
-void LocationAPIClientBase::onCtrlCollectiveResponseCb(
-        size_t count, LocationError* errors, uint32_t* ids)
-{
-    for (size_t i = 0; i < count; i++) {
-        if (errors[i] != LOCATION_ERROR_SUCCESS) {
-            LOC_LOGE("%s:%d] ERROR: %d ID: %d", __FUNCTION__, __LINE__, errors[i], ids[i]);
-        } else {
-            LOC_LOGV("%s:%d] error: %d id: %d", __FUNCTION__, __LINE__, errors[i], ids[i]);
-        }
-    }
-    LocationAPIRequest* request = nullptr;
-    pthread_mutex_lock(&mMutex);
-    if (mRequestQueues[REQUEST_CONFIG].getSession() == CONFIG_SESSION_ID) {
-        request = mRequestQueues[REQUEST_CONFIG].pop();
-    }
-    pthread_mutex_unlock(&mMutex);
-    if (request) {
-        request->onCollectiveResponse(count, errors, ids);
-        delete request;
-    }
-}
-
-LocationAPIClientBase::LocationAPIRequest*
-LocationAPIClientBase::getRequestBySession(uint32_t session)
 {
     pthread_mutex_lock(&mMutex);
     LocationAPIRequest* request = nullptr;
     for (int i = 0; i < REQUEST_MAX; i++) {
         if (i != REQUEST_GEOFENCE &&
-                i != REQUEST_CONFIG &&
                 mRequestQueues[i].getSession() == session) {
             request = mRequestQueues[i].pop();
             break;

location/LocationAPIClientBase.h

@@ -48,14 +48,130 @@ enum REQUEST_TYPE {
     REQUEST_BATCHING,
     REQUEST_GEOFENCE,
     REQUEST_NIRESPONSE,
-    REQUEST_DELETEAIDINGDATA,
-    REQUEST_CONTROL,
-    REQUEST_CONFIG,
     REQUEST_MAX,
 };
 
-class LocationAPIClientBase
+enum CTRL_REQUEST_TYPE {
-{
+    CTRL_REQUEST_DELETEAIDINGDATA = 0,
+    CTRL_REQUEST_CONTROL,
+    CTRL_REQUEST_CONFIG,
+    CTRL_REQUEST_MAX,
+};
+
+class LocationAPIClientBase;
+
+class LocationAPIRequest {
+public:
+    LocationAPIRequest() {}
+    virtual ~LocationAPIRequest() {}
+    virtual void onResponse(LocationError /*error*/) {}
+    virtual void onCollectiveResponse(
+            size_t /*count*/, LocationError* /*errors*/, uint32_t* /*ids*/) {}
+};
+
+class RequestQueue {
+public:
+    RequestQueue(): mSession(0) {
+    }
+    virtual ~RequestQueue() {
+        reset(0);
+    }
+    void reset(uint32_t session) {
+        LocationAPIRequest* request = nullptr;
+        while (!mQueue.empty()) {
+            request = mQueue.front();
+            mQueue.pop();
+            delete request;
+        }
+        mSession = session;
+    }
+    void push(LocationAPIRequest* request) {
+        mQueue.push(request);
+    }
+    LocationAPIRequest* pop() {
+        LocationAPIRequest* request = nullptr;
+        if (!mQueue.empty()) {
+            request = mQueue.front();
+            mQueue.pop();
+        }
+        return request;
+    }
+    uint32_t getSession() { return mSession; }
+private:
+    uint32_t mSession;
+    std::queue<LocationAPIRequest*> mQueue;
+};
+
+class LocationAPIControlClient {
+public:
+    LocationAPIControlClient();
+    virtual ~LocationAPIControlClient();
+    LocationAPIControlClient(const LocationAPIControlClient&) = delete;
+    LocationAPIControlClient& operator=(const LocationAPIControlClient&) = delete;
+
+    LocationAPIRequest* getRequestBySession(uint32_t session);
+
+    // LocationControlAPI
+    uint32_t locAPIGnssDeleteAidingData(GnssAidingData& data);
+    uint32_t locAPIEnable(LocationTechnologyType techType);
+    void locAPIDisable();
+    uint32_t locAPIGnssUpdateConfig(GnssConfig config);
+
+    // callbacks
+    void onCtrlResponseCb(LocationError error, uint32_t id);
+    void onCtrlCollectiveResponseCb(size_t count, LocationError* errors, uint32_t* ids);
+
+    inline virtual void onGnssDeleteAidingDataCb(LocationError /*error*/) {}
+    inline virtual void onEnableCb(LocationError /*error*/) {}
+    inline virtual void onDisableCb(LocationError /*error*/) {}
+    inline virtual void onGnssUpdateConfigCb(
+            size_t /*count*/, LocationError* /*errors*/, uint32_t* /*ids*/) {}
+
+    class GnssDeleteAidingDataRequest : public LocationAPIRequest {
+    public:
+        GnssDeleteAidingDataRequest(LocationAPIControlClient& API) : mAPI(API) {}
+        inline void onResponse(LocationError error) {
+            mAPI.onGnssDeleteAidingDataCb(error);
+        }
+        LocationAPIControlClient& mAPI;
+    };
+
+    class EnableRequest : public LocationAPIRequest {
+    public:
+        EnableRequest(LocationAPIControlClient& API) : mAPI(API) {}
+        inline void onResponse(LocationError error) {
+            mAPI.onEnableCb(error);
+        }
+        LocationAPIControlClient& mAPI;
+    };
+
+    class DisableRequest : public LocationAPIRequest {
+    public:
+        DisableRequest(LocationAPIControlClient& API) : mAPI(API) {}
+        inline void onResponse(LocationError error) {
+            mAPI.onDisableCb(error);
+        }
+        LocationAPIControlClient& mAPI;
+    };
+
+    class GnssUpdateConfigRequest : public LocationAPIRequest {
+    public:
+        GnssUpdateConfigRequest(LocationAPIControlClient& API) : mAPI(API) {}
+        inline void onCollectiveResponse(size_t count, LocationError* errors, uint32_t* ids) {
+            mAPI.onGnssUpdateConfigCb(count, errors, ids);
+        }
+        LocationAPIControlClient& mAPI;
+    };
+
+private:
+    pthread_mutex_t mMutex;
+    LocationControlAPI* mLocationControlAPI;
+    RequestQueue mRequestQueues[CTRL_REQUEST_MAX];
+    bool mEnabled;
+    GnssConfig mConfig;
+};
+
+class LocationAPIClientBase {
 public:
     LocationAPIClientBase();
     virtual ~LocationAPIClientBase();
@@ -63,6 +179,7 @@ public:
     LocationAPIClientBase& operator=(const LocationAPIClientBase&) = delete;
 
     void locAPISetCallbacks(LocationCallbacks& locationCallbacks);
+    LocationAPIRequest* getRequestBySession(uint32_t session);
 
     // LocationAPI
     uint32_t locAPIStartTracking(LocationOptions& options);
@@ -86,19 +203,11 @@ public:
     void locAPIRemoveAllGeofences();
 
     void locAPIGnssNiResponse(uint32_t id, GnssNiResponse response);
-    uint32_t locAPIGnssDeleteAidingData(GnssAidingData& data);
-
-    uint32_t locAPIEnable(LocationTechnologyType techType);
-    void locAPIDisable();
-    uint32_t locAPIGnssUpdateConfig(GnssConfig config);
 
     // callbacks
     void onResponseCb(LocationError error, uint32_t id);
     void onCollectiveResponseCb(size_t count, LocationError* errors, uint32_t* ids);
 
-    void onCtrlResponseCb(LocationError error, uint32_t id);
-    void onCtrlCollectiveResponseCb(size_t count, LocationError* errors, uint32_t* ids);
-
     void beforeGeofenceBreachCb(GeofenceBreachNotification geofenceBreachNotification);
 
     inline virtual void onCapabilitiesCb(LocationCapabilitiesMask /*capabilitiesMask*/) {}
@@ -138,12 +247,6 @@ public:
 
     inline virtual void onGnssNiCb(uint32_t /*id*/, GnssNiNotification /*gnssNiNotification*/) {}
     inline virtual void onGnssNiResponseCb(LocationError /*error*/) {}
-    inline virtual void onGnssDeleteAidingDataCb(LocationError /*error*/) {}
-
-    inline virtual void onEnableCb(LocationError /*error*/) {}
-    inline virtual void onDisableCb(LocationError /*error*/) {}
-    inline virtual void onGnssUpdateConfigCb(
-            size_t /*count*/, LocationError* /*errors*/, uint32_t* /*ids*/) {}
 
 private:
     // private inner classes
@@ -245,75 +348,72 @@ private:
         std::map<uint32_t, uint32_t> mTypeMap;
     };
 
-    class LocationAPIRequest {
-    public:
-        LocationAPIRequest(LocationAPIClientBase& API) : mAPI(API) {}
-        virtual ~LocationAPIRequest() {}
-        virtual void onResponse(LocationError /*error*/) {}
-        virtual void onCollectiveResponse(
-                size_t /*count*/, LocationError* /*errors*/, uint32_t* /*ids*/) {}
-        LocationAPIClientBase& mAPI;
-    };
-
     class StartTrackingRequest : public LocationAPIRequest {
     public:
-        StartTrackingRequest(LocationAPIClientBase& API) : LocationAPIRequest(API) {}
+        StartTrackingRequest(LocationAPIClientBase& API) : mAPI(API) {}
         inline void onResponse(LocationError error) {
             mAPI.onStartTrackingCb(error);
         }
+        LocationAPIClientBase& mAPI;
     };
 
     class StopTrackingRequest : public LocationAPIRequest {
     public:
-        StopTrackingRequest(LocationAPIClientBase& API) : LocationAPIRequest(API) {}
+        StopTrackingRequest(LocationAPIClientBase& API) : mAPI(API) {}
         inline void onResponse(LocationError error) {
             mAPI.onStopTrackingCb(error);
         }
+        LocationAPIClientBase& mAPI;
     };
 
     class UpdateTrackingOptionsRequest : public LocationAPIRequest {
     public:
-        UpdateTrackingOptionsRequest(LocationAPIClientBase& API) : LocationAPIRequest(API) {}
+        UpdateTrackingOptionsRequest(LocationAPIClientBase& API) : mAPI(API) {}
         inline void onResponse(LocationError error) {
             mAPI.onUpdateTrackingOptionsCb(error);
         }
+        LocationAPIClientBase& mAPI;
     };
 
     class StartBatchingRequest : public LocationAPIRequest {
     public:
-        StartBatchingRequest(LocationAPIClientBase& API) : LocationAPIRequest(API) {}
+        StartBatchingRequest(LocationAPIClientBase& API) : mAPI(API) {}
         inline void onResponse(LocationError error) {
             mAPI.onStartBatchingCb(error);
         }
+        LocationAPIClientBase& mAPI;
     };
 
     class StopBatchingRequest : public LocationAPIRequest {
     public:
-        StopBatchingRequest(LocationAPIClientBase& API) : LocationAPIRequest(API) {}
+        StopBatchingRequest(LocationAPIClientBase& API) : mAPI(API) {}
         inline void onResponse(LocationError error) {
             mAPI.onStopBatchingCb(error);
         }
+        LocationAPIClientBase& mAPI;
     };
 
     class UpdateBatchingOptionsRequest : public LocationAPIRequest {
     public:
-        UpdateBatchingOptionsRequest(LocationAPIClientBase& API) : LocationAPIRequest(API) {}
+        UpdateBatchingOptionsRequest(LocationAPIClientBase& API) : mAPI(API) {}
         inline void onResponse(LocationError error) {
             mAPI.onUpdateBatchingOptionsCb(error);
         }
+        LocationAPIClientBase& mAPI;
     };
 
     class GetBatchedLocationsRequest : public LocationAPIRequest {
     public:
-        GetBatchedLocationsRequest(LocationAPIClientBase& API) : LocationAPIRequest(API) {}
+        GetBatchedLocationsRequest(LocationAPIClientBase& API) : mAPI(API) {}
         inline void onResponse(LocationError error) {
             mAPI.onGetBatchedLocationsCb(error);
         }
+        LocationAPIClientBase& mAPI;
     };
 
     class AddGeofencesRequest : public LocationAPIRequest {
     public:
-        AddGeofencesRequest(LocationAPIClientBase& API) : LocationAPIRequest(API) {}
+        AddGeofencesRequest(LocationAPIClientBase& API) : mAPI(API) {}
         inline void onCollectiveResponse(size_t count, LocationError* errors, uint32_t* sessions) {
             uint32_t *ids = (uint32_t*)malloc(sizeof(uint32_t) * count);
             for (size_t i = 0; i < count; i++) {
@@ -322,11 +422,12 @@ private:
             mAPI.onAddGeofencesCb(count, errors, ids);
             free(ids);
         }
+        LocationAPIClientBase& mAPI;
     };
 
     class RemoveGeofencesRequest : public LocationAPIRequest {
     public:
-        RemoveGeofencesRequest(LocationAPIClientBase& API) : LocationAPIRequest(API) {}
+        RemoveGeofencesRequest(LocationAPIClientBase& API) : mAPI(API) {}
         inline void onCollectiveResponse(size_t count, LocationError* errors, uint32_t* sessions) {
             uint32_t *ids = (uint32_t*)malloc(sizeof(uint32_t) * count);
             for (size_t i = 0; i < count; i++) {
@@ -336,11 +437,12 @@ private:
             mAPI.onRemoveGeofencesCb(count, errors, ids);
             free(ids);
         }
+        LocationAPIClientBase& mAPI;
     };
 
     class ModifyGeofencesRequest : public LocationAPIRequest {
     public:
-        ModifyGeofencesRequest(LocationAPIClientBase& API) : LocationAPIRequest(API) {}
+        ModifyGeofencesRequest(LocationAPIClientBase& API) : mAPI(API) {}
         inline void onCollectiveResponse(size_t count, LocationError* errors, uint32_t* sessions) {
             uint32_t *ids = (uint32_t*)malloc(sizeof(uint32_t) * count);
             for (size_t i = 0; i < count; i++) {
@@ -349,11 +451,12 @@ private:
             mAPI.onModifyGeofencesCb(count, errors, ids);
             free(ids);
         }
+        LocationAPIClientBase& mAPI;
     };
 
     class PauseGeofencesRequest : public LocationAPIRequest {
     public:
-        PauseGeofencesRequest(LocationAPIClientBase& API) : LocationAPIRequest(API) {}
+        PauseGeofencesRequest(LocationAPIClientBase& API) : mAPI(API) {}
         inline void onCollectiveResponse(size_t count, LocationError* errors, uint32_t* sessions) {
             uint32_t *ids = (uint32_t*)malloc(sizeof(uint32_t) * count);
             for (size_t i = 0; i < count; i++) {
@@ -362,11 +465,12 @@ private:
             mAPI.onPauseGeofencesCb(count, errors, ids);
             free(ids);
         }
+        LocationAPIClientBase& mAPI;
     };
 
     class ResumeGeofencesRequest : public LocationAPIRequest {
     public:
-        ResumeGeofencesRequest(LocationAPIClientBase& API) : LocationAPIRequest(API) {}
+        ResumeGeofencesRequest(LocationAPIClientBase& API) : mAPI(API) {}
         inline void onCollectiveResponse(size_t count, LocationError* errors, uint32_t* sessions) {
             uint32_t *ids = (uint32_t*)malloc(sizeof(uint32_t) * count);
             for (size_t i = 0; i < count; i++) {
@@ -375,98 +479,29 @@ private:
             mAPI.onResumeGeofencesCb(count, errors, ids);
             free(ids);
         }
+        LocationAPIClientBase& mAPI;
     };
 
     class GnssNiResponseRequest : public LocationAPIRequest {
     public:
-        GnssNiResponseRequest(LocationAPIClientBase& API) : LocationAPIRequest(API) {}
+        GnssNiResponseRequest(LocationAPIClientBase& API) : mAPI(API) {}
         inline void onResponse(LocationError error) {
             mAPI.onGnssNiResponseCb(error);
         }
+        LocationAPIClientBase& mAPI;
     };
 
-    class GnssDeleteAidingDataRequest : public LocationAPIRequest {
-    public:
-        GnssDeleteAidingDataRequest(LocationAPIClientBase& API) : LocationAPIRequest(API) {}
-        inline void onResponse(LocationError error) {
-            mAPI.onGnssDeleteAidingDataCb(error);
-        }
-    };
-
-    class EnableRequest : public LocationAPIRequest {
-    public:
-        EnableRequest(LocationAPIClientBase& API) : LocationAPIRequest(API) {}
-        inline void onResponse(LocationError error) {
-            mAPI.onEnableCb(error);
-        }
-    };
-
-    class DisableRequest : public LocationAPIRequest {
-    public:
-        DisableRequest(LocationAPIClientBase& API) : LocationAPIRequest(API) {}
-        inline void onResponse(LocationError error) {
-            mAPI.onDisableCb(error);
-        }
-    };
-
-    class GnssUpdateConfigRequest : public LocationAPIRequest {
-    public:
-        GnssUpdateConfigRequest(LocationAPIClientBase& API) : LocationAPIRequest(API) {}
-        inline void onCollectiveResponse(size_t count, LocationError* errors, uint32_t* ids) {
-            mAPI.onGnssUpdateConfigCb(count, errors, ids);
-        }
-    };
-
-    class RequestQueue {
-    public:
-        RequestQueue(): mSession(0) {
-        }
-        virtual ~RequestQueue() {
-            reset(0);
-        }
-        void reset(uint32_t session) {
-            LocationAPIRequest* request = nullptr;
-            while (!mQueue.empty()) {
-                request = mQueue.front();
-                mQueue.pop();
-                delete request;
-            }
-            mSession = session;
-        }
-        void push(LocationAPIRequest* request) {
-            mQueue.push(request);
-        }
-        LocationAPIRequest* pop() {
-            LocationAPIRequest* request = nullptr;
-            if (!mQueue.empty()) {
-                request = mQueue.front();
-                mQueue.pop();
-            }
-            return request;
-        }
-        uint32_t getSession() { return mSession; }
-    private:
-        uint32_t mSession;
-        std::queue<LocationAPIRequest*> mQueue;
-    };
-
-    LocationAPIRequest* getRequestBySession(uint32_t session);
-
 private:
     pthread_mutex_t mMutex;
 
     geofenceBreachCallback mGeofenceBreachCallback;
 
     LocationAPI* mLocationAPI;
-    LocationControlAPI* mLocationControlAPI;
 
     RequestQueue mRequestQueues[REQUEST_MAX];
     BiDict mGeofenceBiDict;
     std::map<uint32_t, SessionEntity> mSessionMap;
     int32_t mBatchSize;
-    bool mEnabled;
-
-    GnssConfig mConfig;
 };
 
 #endif /* LOCATION_API_CLINET_BASE_H */