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
This commit is contained in:
Baili Feng
parent
1e6d1c02ce
commit
1a128bd7cd
6 changed files with 413 additions and 302 deletions
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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();
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
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<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;
|
||||
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<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());
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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 */
|
||||
|
|
|
|||
Loading…
Reference in a new issue