diff --git a/android/AGnssRil.cpp b/android/AGnssRil.cpp index b19f55f5..ec3dd761 100644 --- a/android/AGnssRil.cpp +++ b/android/AGnssRil.cpp @@ -47,7 +47,7 @@ AGnssRil::~AGnssRil() { ENTRY_LOG_CALLFLOW(); } -Return AGnssRil::updateNetworkState(bool connected, NetworkType type, bool roaming) { +Return AGnssRil::updateNetworkState(bool connected, NetworkType type, bool /*roaming*/) { ENTRY_LOG_CALLFLOW(); // for XTRA diff --git a/android/Gnss.cpp b/android/Gnss.cpp index 9b2e7ddc..e3fd64ee 100644 --- a/android/Gnss.cpp +++ b/android/Gnss.cpp @@ -120,7 +120,7 @@ Return Gnss::setCallback(const sp& 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 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 Gnss::cleanup() { ENTRY_LOG_CALLFLOW(); if (mApi != nullptr) { - mApi->locAPIDisable(); + mApi->gnssDisable(); } return Void(); diff --git a/android/location_api/GnssAPIClient.cpp b/android/location_api/GnssAPIClient.cpp index 852edfb3..af2998de 100644 --- a/android/location_api/GnssAPIClient.cpp +++ b/android/location_api/GnssAPIClient.cpp @@ -50,6 +50,7 @@ GnssAPIClient::GnssAPIClient(const sp& gpsCb, LocationAPIClientBase(), mGnssCbIface(nullptr), mGnssNiCbIface(nullptr), + mControlClient(new LocationAPIControlClient()), mLocationCapabilitiesMask(0), mLocationCapabilitiesCached(false) { @@ -68,6 +69,10 @@ GnssAPIClient::GnssAPIClient(const sp& 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(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, - IGnss::GnssPositionRecurrence recurrence, uint32_t minIntervalMs, - uint32_t preferredAccuracyMeters, uint32_t preferredTimeMs) +void GnssAPIClient::gnssEnable(LocationTechnologyType techType) { - 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; - locAPIUpdateTrackingOptions(mLocationOptions); - return retVal; + LOC_LOGD("%s]: (%0d)", __FUNCTION__, techType); + if (mControlClient == nullptr) { + return; + } + mControlClient->locAPIEnable(techType); } -// for GpsNiInterface -void GnssAPIClient::gnssNiRespond(int32_t notifId, - IGnssNiCallback::GnssUserResponseType userResponse) +void GnssAPIClient::gnssDisable() { - LOC_LOGD("%s]: (%d %d)", __FUNCTION__, notifId, static_cast(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; - locAPIGnssNiResponse(notifId, data); + LOC_LOGD("%s]: ()", __FUNCTION__); + if (mControlClient == nullptr) { + return; + } + mControlClient->locAPIDisable(); } -// 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(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()); } } diff --git a/android/location_api/GnssAPIClient.h b/android/location_api/GnssAPIClient.h index d447157a..295a9e9b 100644 --- a/android/location_api/GnssAPIClient.h +++ b/android/location_api/GnssAPIClient.h @@ -58,7 +58,6 @@ public: const sp& 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 mGnssCbIface; sp mGnssNiCbIface; + LocationAPIControlClient* mControlClient; LocationCapabilitiesMask mLocationCapabilitiesMask; bool mLocationCapabilitiesCached; diff --git a/location/LocationAPIClientBase.cpp b/location/LocationAPIClientBase.cpp index dcf19715..bf1a8ad1 100644 --- a/location/LocationAPIClientBase.cpp +++ b/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), - mEnabled(false) + mBatchSize(-1) { // 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) -{ - 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) +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; diff --git a/location/LocationAPIClientBase.h b/location/LocationAPIClientBase.h index 144f99c4..354e51ff 100644 --- a/location/LocationAPIClientBase.h +++ b/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 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 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 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 mSessionMap; int32_t mBatchSize; - bool mEnabled; - - GnssConfig mConfig; }; #endif /* LOCATION_API_CLINET_BASE_H */