aboutsummaryrefslogtreecommitdiff
path: root/gps
diff options
context:
space:
mode:
Diffstat (limited to 'gps')
-rw-r--r--gps/android/AGnss.cpp25
-rw-r--r--gps/android/AGnss.h6
-rw-r--r--gps/android/AGnssRil.cpp32
-rw-r--r--gps/android/location_api/GnssAPIClient.cpp31
-rw-r--r--gps/android/location_api/GnssAPIClient.h5
-rw-r--r--gps/android/location_api/MeasurementAPIClient.cpp10
-rw-r--r--gps/android/location_api/MeasurementAPIClient.h4
-rw-r--r--gps/core/SystemStatus.cpp686
-rw-r--r--gps/core/SystemStatus.h488
-rw-r--r--gps/core/SystemStatusOsObserver.cpp12
-rw-r--r--gps/core/SystemStatusOsObserver.h6
-rw-r--r--gps/core/data-items/DataItemConcreteTypesBase.h461
-rw-r--r--gps/gnss/XtraSystemStatusObserver.cpp11
-rw-r--r--gps/location/LocationAPI.h5
-rw-r--r--gps/location/LocationAPIClientBase.cpp110
-rw-r--r--gps/location/LocationAPIClientBase.h20
16 files changed, 1251 insertions, 661 deletions
diff --git a/gps/android/AGnss.cpp b/gps/android/AGnss.cpp
index 6213a08..3602e85 100644
--- a/gps/android/AGnss.cpp
+++ b/gps/android/AGnss.cpp
@@ -30,12 +30,23 @@ namespace gnss {
namespace V1_0 {
namespace implementation {
-sp<IAGnssCallback> AGnss::sAGnssCbIface = nullptr;
+static AGnss* spAGnss = nullptr;
AGnss::AGnss(Gnss* gnss) : mGnss(gnss) {
+ spAGnss = this;
+}
+
+AGnss::~AGnss() {
+ spAGnss = nullptr;
}
void AGnss::agnssStatusIpV4Cb(AGnssExtStatusIpV4 status){
+ if (nullptr != spAGnss) {
+ spAGnss->statusIpV4Cb(status);
+ }
+}
+
+void AGnss::statusIpV4Cb(AGnssExtStatusIpV4 status) {
IAGnssCallback::AGnssStatusIpV4 st = {};
switch (status.type) {
@@ -72,9 +83,13 @@ void AGnss::agnssStatusIpV4Cb(AGnssExtStatusIpV4 status){
}
st.ipV4Addr = status.ipV4Addr;
- auto r = sAGnssCbIface->agnssStatusIpV4Cb(st);
- if (!r.isOk()) {
- LOC_LOGE("Error invoking AGNSS status cb %s", r.description().c_str());
+ if (mAGnssCbIface != nullptr) {
+ auto r = mAGnssCbIface->agnssStatusIpV4Cb(st);
+ if (!r.isOk()) {
+ LOC_LOGw("Error invoking AGNSS status cb %s", r.description().c_str());
+ }
+ } else {
+ LOC_LOGw("setCallback has not been called yet");
}
}
@@ -86,7 +101,7 @@ Return<void> AGnss::setCallback(const sp<IAGnssCallback>& callback) {
}
// Save the interface
- sAGnssCbIface = callback;
+ mAGnssCbIface = callback;
AgpsCbInfo cbInfo = {};
cbInfo.statusV4Cb = (void*)agnssStatusIpV4Cb;
diff --git a/gps/android/AGnss.h b/gps/android/AGnss.h
index a3f4a87..ead6416 100644
--- a/gps/android/AGnss.h
+++ b/gps/android/AGnss.h
@@ -43,7 +43,7 @@ struct Gnss;
struct AGnss : public IAGnss {
AGnss(Gnss* gnss);
- ~AGnss() = default;
+ ~AGnss();
/*
* Methods from ::android::hardware::gnss::V1_0::IAGnss interface follow.
* These declarations were generated from IAGnss.hal.
@@ -60,12 +60,14 @@ struct AGnss : public IAGnss {
Return<bool> setServer(IAGnssCallback::AGnssType type,
const hidl_string& hostname, int32_t port) override;
+ void statusIpV4Cb(AGnssExtStatusIpV4 status);
+
/* Data call setup callback passed down to GNSS HAL implementation */
static void agnssStatusIpV4Cb(AGnssExtStatusIpV4 status);
private:
Gnss* mGnss = nullptr;
- static sp<IAGnssCallback> sAGnssCbIface;
+ sp<IAGnssCallback> mAGnssCbIface = nullptr;
};
} // namespace implementation
diff --git a/gps/android/AGnssRil.cpp b/gps/android/AGnssRil.cpp
index bd4bb37..d790bae 100644
--- a/gps/android/AGnssRil.cpp
+++ b/gps/android/AGnssRil.cpp
@@ -29,6 +29,8 @@
#include <string>
#include "Gnss.h"
#include "AGnssRil.h"
+#include <DataItemConcreteTypesBase.h>
+
typedef void* (getLocationInterface)();
namespace android {
@@ -51,7 +53,35 @@ Return<bool> AGnssRil::updateNetworkState(bool connected, NetworkType type, bool
// for XTRA
if (nullptr != mGnss && ( nullptr != mGnss->getGnssInterface() )) {
- mGnss->getGnssInterface()->updateConnectionStatus(connected, (uint8_t)type);
+ int8_t typeout = loc_core::NetworkInfoDataItemBase::TYPE_UNKNOWN;
+ switch(type)
+ {
+ case IAGnssRil::NetworkType::MOBILE:
+ typeout = loc_core::NetworkInfoDataItemBase::TYPE_MOBILE;
+ break;
+ case IAGnssRil::NetworkType::WIFI:
+ typeout = loc_core::NetworkInfoDataItemBase::TYPE_WIFI;
+ break;
+ case IAGnssRil::NetworkType::MMS:
+ typeout = loc_core::NetworkInfoDataItemBase::TYPE_MMS;
+ break;
+ case IAGnssRil::NetworkType::SUPL:
+ typeout = loc_core::NetworkInfoDataItemBase::TYPE_SUPL;
+ break;
+ case IAGnssRil::NetworkType::DUN:
+ typeout = loc_core::NetworkInfoDataItemBase::TYPE_DUN;
+ break;
+ case IAGnssRil::NetworkType::HIPRI:
+ typeout = loc_core::NetworkInfoDataItemBase::TYPE_HIPRI;
+ break;
+ case IAGnssRil::NetworkType::WIMAX:
+ typeout = loc_core::NetworkInfoDataItemBase::TYPE_WIMAX;
+ break;
+ default:
+ typeout = loc_core::NetworkInfoDataItemBase::TYPE_UNKNOWN;
+ break;
+ }
+ mGnss->getGnssInterface()->updateConnectionStatus(connected, typeout);
}
return true;
}
diff --git a/gps/android/location_api/GnssAPIClient.cpp b/gps/android/location_api/GnssAPIClient.cpp
index 2745f56..2e44c2e 100644
--- a/gps/android/location_api/GnssAPIClient.cpp
+++ b/gps/android/location_api/GnssAPIClient.cpp
@@ -81,8 +81,10 @@ void GnssAPIClient::gnssUpdateCallbacks(const sp<IGnssCallback>& gpsCb,
{
LOC_LOGD("%s]: (%p %p)", __FUNCTION__, &gpsCb, &niCb);
+ mMutex.lock();
mGnssCbIface = gpsCb;
mGnssNiCbIface = niCb;
+ mMutex.unlock();
LocationCallbacks locationCallbacks;
memset(&locationCallbacks, 0, sizeof(LocationCallbacks));
@@ -278,7 +280,10 @@ void GnssAPIClient::onCapabilitiesCb(LocationCapabilitiesMask capabilitiesMask)
LOC_LOGD("%s]: (%02x)", __FUNCTION__, capabilitiesMask);
mLocationCapabilitiesMask = capabilitiesMask;
mLocationCapabilitiesCached = true;
- sp<IGnssCallback> gnssCbIface = mGnssCbIface;
+
+ mMutex.lock();
+ auto gnssCbIface(mGnssCbIface);
+ mMutex.unlock();
if (gnssCbIface != nullptr) {
uint32_t data = 0;
@@ -322,7 +327,9 @@ void GnssAPIClient::onCapabilitiesCb(LocationCapabilitiesMask capabilitiesMask)
void GnssAPIClient::onTrackingCb(Location location)
{
LOC_LOGD("%s]: (flags: %02x)", __FUNCTION__, location.flags);
- sp<IGnssCallback> gnssCbIface = mGnssCbIface;
+ mMutex.lock();
+ auto gnssCbIface(mGnssCbIface);
+ mMutex.unlock();
if (gnssCbIface != nullptr) {
GnssLocation gnssLocation;
@@ -338,7 +345,9 @@ void GnssAPIClient::onTrackingCb(Location location)
void GnssAPIClient::onGnssNiCb(uint32_t id, GnssNiNotification gnssNiNotification)
{
LOC_LOGD("%s]: (id: %d)", __FUNCTION__, id);
- sp<IGnssNiCallback> gnssNiCbIface = mGnssNiCbIface;
+ mMutex.lock();
+ auto gnssNiCbIface(mGnssNiCbIface);
+ mMutex.unlock();
if (gnssNiCbIface == nullptr) {
LOC_LOGE("%s]: mGnssNiCbIface is nullptr", __FUNCTION__);
@@ -411,7 +420,9 @@ void GnssAPIClient::onGnssNiCb(uint32_t id, GnssNiNotification gnssNiNotificatio
void GnssAPIClient::onGnssSvCb(GnssSvNotification gnssSvNotification)
{
LOC_LOGD("%s]: (count: %zu)", __FUNCTION__, gnssSvNotification.count);
- sp<IGnssCallback> gnssCbIface = mGnssCbIface;
+ mMutex.lock();
+ auto gnssCbIface(mGnssCbIface);
+ mMutex.unlock();
if (gnssCbIface != nullptr) {
IGnssCallback::GnssSvStatus svStatus;
@@ -426,7 +437,9 @@ void GnssAPIClient::onGnssSvCb(GnssSvNotification gnssSvNotification)
void GnssAPIClient::onGnssNmeaCb(GnssNmeaNotification gnssNmeaNotification)
{
- sp<IGnssCallback> gnssCbIface = mGnssCbIface;
+ mMutex.lock();
+ auto gnssCbIface(mGnssCbIface);
+ mMutex.unlock();
if (gnssCbIface != nullptr) {
android::hardware::hidl_string nmeaString;
@@ -443,7 +456,9 @@ void GnssAPIClient::onGnssNmeaCb(GnssNmeaNotification gnssNmeaNotification)
void GnssAPIClient::onStartTrackingCb(LocationError error)
{
LOC_LOGD("%s]: (%d)", __FUNCTION__, error);
- sp<IGnssCallback> gnssCbIface = mGnssCbIface;
+ mMutex.lock();
+ auto gnssCbIface(mGnssCbIface);
+ mMutex.unlock();
if (error == LOCATION_ERROR_SUCCESS && gnssCbIface != nullptr) {
auto r = gnssCbIface->gnssStatusCb(IGnssCallback::GnssStatusValue::ENGINE_ON);
@@ -462,7 +477,9 @@ void GnssAPIClient::onStartTrackingCb(LocationError error)
void GnssAPIClient::onStopTrackingCb(LocationError error)
{
LOC_LOGD("%s]: (%d)", __FUNCTION__, error);
- sp<IGnssCallback> gnssCbIface = mGnssCbIface;
+ mMutex.lock();
+ auto gnssCbIface(mGnssCbIface);
+ mMutex.unlock();
if (error == LOCATION_ERROR_SUCCESS && gnssCbIface != nullptr) {
auto r = gnssCbIface->gnssStatusCb(IGnssCallback::GnssStatusValue::SESSION_END);
diff --git a/gps/android/location_api/GnssAPIClient.h b/gps/android/location_api/GnssAPIClient.h
index 295a9e9..b5cffb1 100644
--- a/gps/android/location_api/GnssAPIClient.h
+++ b/gps/android/location_api/GnssAPIClient.h
@@ -30,7 +30,7 @@
#ifndef GNSS_API_CLINET_H
#define GNSS_API_CLINET_H
-
+#include <mutex>
#include <android/hardware/gnss/1.0/IGnss.h>
#include <android/hardware/gnss/1.0/IGnssCallback.h>
#include <android/hardware/gnss/1.0/IGnssNiCallback.h>
@@ -91,11 +91,10 @@ public:
private:
sp<IGnssCallback> mGnssCbIface;
sp<IGnssNiCallback> mGnssNiCbIface;
-
+ std::mutex mMutex;
LocationAPIControlClient* mControlClient;
LocationCapabilitiesMask mLocationCapabilitiesMask;
bool mLocationCapabilitiesCached;
-
LocationOptions mLocationOptions;
};
diff --git a/gps/android/location_api/MeasurementAPIClient.cpp b/gps/android/location_api/MeasurementAPIClient.cpp
index dd7ceac..731c7ed 100644
--- a/gps/android/location_api/MeasurementAPIClient.cpp
+++ b/gps/android/location_api/MeasurementAPIClient.cpp
@@ -66,7 +66,9 @@ MeasurementAPIClient::measurementSetCallback(const sp<IGnssMeasurementCallback>&
{
LOC_LOGD("%s]: (%p)", __FUNCTION__, &callback);
+ mMutex.lock();
mGnssMeasurementCbIface = callback;
+ mMutex.unlock();
LocationCallbacks locationCallbacks;
memset(&locationCallbacks, 0, sizeof(LocationCallbacks));
@@ -116,10 +118,14 @@ void MeasurementAPIClient::onGnssMeasurementsCb(
LOC_LOGD("%s]: (count: %zu active: %zu)",
__FUNCTION__, gnssMeasurementsNotification.count, mTracking);
if (mTracking) {
- if (mGnssMeasurementCbIface != nullptr) {
+ mMutex.lock();
+ auto gnssMeasurementCbIface(mGnssMeasurementCbIface);
+ mMutex.unlock();
+
+ if (gnssMeasurementCbIface != nullptr) {
IGnssMeasurementCallback::GnssData gnssData;
convertGnssData(gnssMeasurementsNotification, gnssData);
- auto r = mGnssMeasurementCbIface->GnssMeasurementCb(gnssData);
+ auto r = gnssMeasurementCbIface->GnssMeasurementCb(gnssData);
if (!r.isOk()) {
LOC_LOGE("%s] Error from GnssMeasurementCb description=%s",
__func__, r.description().c_str());
diff --git a/gps/android/location_api/MeasurementAPIClient.h b/gps/android/location_api/MeasurementAPIClient.h
index 422564d..8de1326 100644
--- a/gps/android/location_api/MeasurementAPIClient.h
+++ b/gps/android/location_api/MeasurementAPIClient.h
@@ -30,7 +30,7 @@
#ifndef MEASUREMENT_API_CLINET_H
#define MEASUREMENT_API_CLINET_H
-
+#include <mutex>
#include <android/hardware/gnss/1.0/IGnssMeasurement.h>
#include <android/hardware/gnss/1.0/IGnssMeasurementCallback.h>
#include <LocationAPIClientBase.h>
@@ -63,7 +63,7 @@ public:
private:
sp<IGnssMeasurementCallback> mGnssMeasurementCbIface;
-
+ std::mutex mMutex;
bool mTracking;
};
diff --git a/gps/core/SystemStatus.cpp b/gps/core/SystemStatus.cpp
index 52d28c7..92ddeed 100644
--- a/gps/core/SystemStatus.cpp
+++ b/gps/core/SystemStatus.cpp
@@ -40,6 +40,7 @@
#include <DataItemsFactoryProxy.h>
#include <SystemStatus.h>
#include <SystemStatusOsObserver.h>
+#include <DataItemConcreteTypesBase.h>
namespace loc_core
{
@@ -150,6 +151,7 @@ private:
eAgcGlo = 20,
eAgcBds = 21,
eAgcGal = 22,
+ eMax0 = eAgcGal,
eLeapSeconds = 23,
eLeapSecUnc = 24,
eMax
@@ -186,7 +188,7 @@ public:
: SystemStatusNmeaBase(str_in, len_in)
{
memset(&mM1, 0, sizeof(mM1));
- if (mField.size() < eMax) {
+ if (mField.size() <= eMax0) {
LOC_LOGE("PQWM1parser - invalid size=%zu", mField.size());
mM1.mTimeValid = 0;
return;
@@ -213,8 +215,10 @@ public:
mM1.mAgcGlo = atof(mField[eAgcGlo].c_str());
mM1.mAgcBds = atof(mField[eAgcBds].c_str());
mM1.mAgcGal = atof(mField[eAgcGal].c_str());
- mM1.mLeapSeconds = atoi(mField[eLeapSeconds].c_str());
- mM1.mLeapSecUnc = atoi(mField[eLeapSecUnc].c_str());
+ if (mField.size() > eLeapSecUnc) {
+ mM1.mLeapSeconds = atoi(mField[eLeapSeconds].c_str());
+ mM1.mLeapSecUnc = atoi(mField[eLeapSecUnc].c_str());
+ }
}
inline SystemStatusPQWM1& get() { return mM1;} //getparser
@@ -689,7 +693,7 @@ SystemStatusTimeAndClock::SystemStatusTimeAndClock(const SystemStatusPQWM1& nmea
{
}
-bool SystemStatusTimeAndClock::equals(SystemStatusTimeAndClock& peer)
+bool SystemStatusTimeAndClock::equals(const SystemStatusTimeAndClock& peer)
{
if ((mGpsWeek != peer.mGpsWeek) ||
(mGpsTowMs != peer.mGpsTowMs) ||
@@ -729,7 +733,7 @@ SystemStatusXoState::SystemStatusXoState(const SystemStatusPQWM1& nmea) :
{
}
-bool SystemStatusXoState::equals(SystemStatusXoState& peer)
+bool SystemStatusXoState::equals(const SystemStatusXoState& peer)
{
if (mXoState != peer.mXoState) {
return false;
@@ -765,7 +769,7 @@ SystemStatusRfAndParams::SystemStatusRfAndParams(const SystemStatusPQWM1& nmea)
{
}
-bool SystemStatusRfAndParams::equals(SystemStatusRfAndParams& peer)
+bool SystemStatusRfAndParams::equals(const SystemStatusRfAndParams& peer)
{
if ((mPgaGain != peer.mPgaGain) ||
(mGpsBpAmpI != peer.mGpsBpAmpI) ||
@@ -815,7 +819,7 @@ SystemStatusErrRecovery::SystemStatusErrRecovery(const SystemStatusPQWM1& nmea)
{
}
-bool SystemStatusErrRecovery::equals(SystemStatusErrRecovery& peer)
+bool SystemStatusErrRecovery::equals(const SystemStatusErrRecovery& peer)
{
if (mRecErrorRecovery != peer.mRecErrorRecovery) {
return false;
@@ -845,7 +849,7 @@ SystemStatusInjectedPosition::SystemStatusInjectedPosition(const SystemStatusPQW
{
}
-bool SystemStatusInjectedPosition::equals(SystemStatusInjectedPosition& peer)
+bool SystemStatusInjectedPosition::equals(const SystemStatusInjectedPosition& peer)
{
if ((mEpiValidity != peer.mEpiValidity) ||
(mEpiLat != peer.mEpiLat) ||
@@ -886,7 +890,7 @@ SystemStatusBestPosition::SystemStatusBestPosition(const SystemStatusPQWP2& nmea
{
}
-bool SystemStatusBestPosition::equals(SystemStatusBestPosition& peer)
+bool SystemStatusBestPosition::equals(const SystemStatusBestPosition& peer)
{
if ((mBestLat != peer.mBestLat) ||
(mBestLon != peer.mBestLon) ||
@@ -928,7 +932,7 @@ SystemStatusXtra::SystemStatusXtra(const SystemStatusPQWP3& nmea) :
{
}
-bool SystemStatusXtra::equals(SystemStatusXtra& peer)
+bool SystemStatusXtra::equals(const SystemStatusXtra& peer)
{
if ((mXtraValidMask != peer.mXtraValidMask) ||
(mGpsXtraAge != peer.mGpsXtraAge) ||
@@ -976,7 +980,7 @@ SystemStatusEphemeris::SystemStatusEphemeris(const SystemStatusPQWP4& nmea) :
{
}
-bool SystemStatusEphemeris::equals(SystemStatusEphemeris& peer)
+bool SystemStatusEphemeris::equals(const SystemStatusEphemeris& peer)
{
if ((mGpsEpheValid != peer.mGpsEpheValid) ||
(mGloEpheValid != peer.mGloEpheValid) ||
@@ -1022,7 +1026,7 @@ SystemStatusSvHealth::SystemStatusSvHealth(const SystemStatusPQWP5& nmea) :
{
}
-bool SystemStatusSvHealth::equals(SystemStatusSvHealth& peer)
+bool SystemStatusSvHealth::equals(const SystemStatusSvHealth& peer)
{
if ((mGpsUnknownMask != peer.mGpsUnknownMask) ||
(mGloUnknownMask != peer.mGloUnknownMask) ||
@@ -1077,7 +1081,7 @@ SystemStatusPdr::SystemStatusPdr(const SystemStatusPQWP6& nmea) :
{
}
-bool SystemStatusPdr::equals(SystemStatusPdr& peer)
+bool SystemStatusPdr::equals(const SystemStatusPdr& peer)
{
if (mFixInfoMask != peer.mFixInfoMask) {
return false;
@@ -1103,7 +1107,7 @@ SystemStatusNavData::SystemStatusNavData(const SystemStatusPQWP7& nmea)
}
}
-bool SystemStatusNavData::equals(SystemStatusNavData& peer)
+bool SystemStatusNavData::equals(const SystemStatusNavData& peer)
{
for (uint32_t i=0; i<SV_ALL_NUM; i++) {
if ((mNav[i].mType != peer.mNav[i].mType) ||
@@ -1135,7 +1139,7 @@ SystemStatusPositionFailure::SystemStatusPositionFailure(const SystemStatusPQWS1
{
}
-bool SystemStatusPositionFailure::equals(SystemStatusPositionFailure& peer)
+bool SystemStatusPositionFailure::equals(const SystemStatusPositionFailure& peer)
{
if ((mFixInfoMask != peer.mFixInfoMask) ||
(mHepeLimit != peer.mHepeLimit)) {
@@ -1156,7 +1160,7 @@ void SystemStatusPositionFailure::dump()
/******************************************************************************
SystemStatusLocation
******************************************************************************/
-bool SystemStatusLocation::equals(SystemStatusLocation& peer)
+bool SystemStatusLocation::equals(const SystemStatusLocation& peer)
{
if ((mLocation.gpsLocation.latitude != peer.mLocation.gpsLocation.latitude) ||
(mLocation.gpsLocation.longitude != peer.mLocation.gpsLocation.longitude) ||
@@ -1213,7 +1217,7 @@ IOsObserver* SystemStatus::getOsObserver()
}
SystemStatus::SystemStatus(const MsgTask* msgTask) :
- mSysStatusObsvr(msgTask),
+ mSysStatusObsvr(this, msgTask),
mConnected(false)
{
int result = 0;
@@ -1235,206 +1239,76 @@ SystemStatus::SystemStatus(const MsgTask* msgTask) :
mCache.mPositionFailure.clear();
- EXIT_LOG_WITH_ERROR ("%d",result);
-}
-
-/******************************************************************************
- SystemStatus - M1 functions
-******************************************************************************/
-bool SystemStatus::setTimeAndCLock(const SystemStatusPQWM1& nmea)
-{
- SystemStatusTimeAndClock s(nmea);
- if (!mCache.mTimeAndClock.empty() && mCache.mTimeAndClock.back().equals(s)) {
- mCache.mTimeAndClock.back().mUtcReported = s.mUtcReported;
- } else {
- mCache.mTimeAndClock.push_back(s);
- if (mCache.mTimeAndClock.size() > maxTimeAndClock) {
- mCache.mTimeAndClock.erase(mCache.mTimeAndClock.begin());
- }
- }
- return true;
-}
-
-bool SystemStatus::setXoState(const SystemStatusPQWM1& nmea)
-{
- SystemStatusXoState s(nmea);
- if (!mCache.mXoState.empty() && mCache.mXoState.back().equals(s)) {
- mCache.mXoState.back().mUtcReported = s.mUtcReported;
- } else {
- mCache.mXoState.push_back(s);
- if (mCache.mXoState.size() > maxXoState) {
- mCache.mXoState.erase(mCache.mXoState.begin());
- }
- }
- return true;
-}
+ mCache.mAirplaneMode.clear();
+ mCache.mENH.clear();
+ mCache.mGPSState.clear();
+ mCache.mNLPStatus.clear();
+ mCache.mWifiHardwareState.clear();
+ mCache.mNetworkInfo.clear();
+ mCache.mRilServiceInfo.clear();
+ mCache.mRilCellInfo.clear();
+ mCache.mServiceStatus.clear();
+ mCache.mModel.clear();
+ mCache.mManufacturer.clear();
+ mCache.mAssistedGps.clear();
+ mCache.mScreenState.clear();
+ mCache.mPowerConnectState.clear();
+ mCache.mTimeZoneChange.clear();
+ mCache.mTimeChange.clear();
+ mCache.mWifiSupplicantStatus.clear();
+ mCache.mShutdownState.clear();
+ mCache.mTac.clear();
+ mCache.mMccMnc.clear();
+ mCache.mBtDeviceScanDetail.clear();
+ mCache.mBtLeDeviceScanDetail.clear();
-bool SystemStatus::setRfAndParams(const SystemStatusPQWM1& nmea)
-{
- SystemStatusRfAndParams s(nmea);
- if (!mCache.mRfAndParams.empty() && mCache.mRfAndParams.back().equals(s)) {
- mCache.mRfAndParams.back().mUtcReported = s.mUtcReported;
- } else {
- mCache.mRfAndParams.push_back(s);
- if (mCache.mRfAndParams.size() > maxRfAndParams) {
- mCache.mRfAndParams.erase(mCache.mRfAndParams.begin());
- }
- }
- return true;
-}
-
-bool SystemStatus::setErrRecovery(const SystemStatusPQWM1& nmea)
-{
- SystemStatusErrRecovery s(nmea);
- if (!mCache.mErrRecovery.empty() && mCache.mErrRecovery.back().equals(s)) {
- mCache.mErrRecovery.back().mUtcReported = s.mUtcReported;
- } else {
- mCache.mErrRecovery.push_back(s);
- if (mCache.mErrRecovery.size() > maxErrRecovery) {
- mCache.mErrRecovery.erase(mCache.mErrRecovery.begin());
- }
- }
- return true;
+ EXIT_LOG_WITH_ERROR ("%d",result);
}
/******************************************************************************
- SystemStatus - Px functions
+ SystemStatus - storing dataitems
******************************************************************************/
-bool SystemStatus::setInjectedPosition(const SystemStatusPQWP1& nmea)
-{
- SystemStatusInjectedPosition s(nmea);
- if (!mCache.mInjectedPosition.empty() && mCache.mInjectedPosition.back().equals(s)) {
- mCache.mInjectedPosition.back().mUtcReported = s.mUtcReported;
- } else {
- mCache.mInjectedPosition.push_back(s);
- if (mCache.mInjectedPosition.size() > maxInjectedPosition) {
- mCache.mInjectedPosition.erase(mCache.mInjectedPosition.begin());
- }
- }
- return true;
-}
-
-bool SystemStatus::setBestPosition(const SystemStatusPQWP2& nmea)
-{
- SystemStatusBestPosition s(nmea);
- if (!mCache.mBestPosition.empty() && mCache.mBestPosition.back().equals(s)) {
- mCache.mBestPosition.back().mUtcReported = s.mUtcReported;
- } else {
- mCache.mBestPosition.push_back(s);
- if (mCache.mBestPosition.size() > maxBestPosition) {
- mCache.mBestPosition.erase(mCache.mBestPosition.begin());
- }
- }
- return true;
-}
-
-bool SystemStatus::setXtra(const SystemStatusPQWP3& nmea)
+template <typename TYPE_SYSTEMSTATUS_ITEM, typename TYPE_REPORT, typename TYPE_ITEMBASE>
+bool SystemStatus::setItemBaseinReport(TYPE_REPORT& report, const TYPE_ITEMBASE& s)
{
- SystemStatusXtra s(nmea);
- if (!mCache.mXtra.empty() && mCache.mXtra.back().equals(s)) {
- mCache.mXtra.back().mUtcReported = s.mUtcReported;
- } else {
- mCache.mXtra.push_back(s);
- if (mCache.mXtra.size() > maxXtra) {
- mCache.mXtra.erase(mCache.mXtra.begin());
- }
- }
- return true;
+ TYPE_SYSTEMSTATUS_ITEM sout(s);
+ return setIteminReport(report, sout);
}
-bool SystemStatus::setEphemeris(const SystemStatusPQWP4& nmea)
+template <typename TYPE_REPORT, typename TYPE_ITEM>
+bool SystemStatus::setIteminReport(TYPE_REPORT& report, const TYPE_ITEM& s)
{
- SystemStatusEphemeris s(nmea);
- if (!mCache.mEphemeris.empty() && mCache.mEphemeris.back().equals(s)) {
- mCache.mEphemeris.back().mUtcReported = s.mUtcReported;
- } else {
- mCache.mEphemeris.push_back(s);
- if (mCache.mEphemeris.size() > maxEphemeris) {
- mCache.mEphemeris.erase(mCache.mEphemeris.begin());
- }
+ if (!report.empty() && report.back().equals(s)) {
+ // there is no change - just update reported timestamp
+ report.back().mUtcReported = s.mUtcReported;
+ return false;
}
- return true;
-}
-bool SystemStatus::setSvHealth(const SystemStatusPQWP5& nmea)
-{
- SystemStatusSvHealth s(nmea);
- if (!mCache.mSvHealth.empty() && mCache.mSvHealth.back().equals(s)) {
- mCache.mSvHealth.back().mUtcReported = s.mUtcReported;
- } else {
- mCache.mSvHealth.push_back(s);
- if (mCache.mSvHealth.size() > maxSvHealth) {
- mCache.mSvHealth.erase(mCache.mSvHealth.begin());
- }
+ // first event or updated
+ report.push_back(s);
+ if (report.size() > s.maxItem) {
+ report.erase(report.begin());
}
return true;
}
-bool SystemStatus::setPdr(const SystemStatusPQWP6& nmea)
+template <typename TYPE_REPORT, typename TYPE_ITEM>
+void SystemStatus::setDefaultIteminReport(TYPE_REPORT& report, const TYPE_ITEM& s)
{
- SystemStatusPdr s(nmea);
- if (!mCache.mPdr.empty() && mCache.mPdr.back().equals(s)) {
- mCache.mPdr.back().mUtcReported = s.mUtcReported;
- } else {
- mCache.mPdr.push_back(s);
- if (mCache.mPdr.size() > maxPdr) {
- mCache.mPdr.erase(mCache.mPdr.begin());
- }
+ report.push_back(s);
+ if (report.size() > s.maxItem) {
+ report.erase(report.begin());
}
- return true;
}
-bool SystemStatus::setNavData(const SystemStatusPQWP7& nmea)
+template <typename TYPE_REPORT, typename TYPE_ITEM>
+void SystemStatus::getIteminReport(TYPE_REPORT& reportout, const TYPE_ITEM& c) const
{
- SystemStatusNavData s(nmea);
- if (!mCache.mNavData.empty() && mCache.mNavData.back().equals(s)) {
- mCache.mNavData.back().mUtcReported = s.mUtcReported;
- } else {
- mCache.mNavData.push_back(s);
- if (mCache.mNavData.size() > maxNavData) {
- mCache.mNavData.erase(mCache.mNavData.begin());
- }
+ reportout.clear();
+ if (c.size() >= 1) {
+ reportout.push_back(c.back());
+ reportout.back().dump();
}
- return true;
-}
-
-/******************************************************************************
- SystemStatus - Sx functions
-******************************************************************************/
-bool SystemStatus::setPositionFailure(const SystemStatusPQWS1& nmea)
-{
- SystemStatusPositionFailure s(nmea);
- if (!mCache.mPositionFailure.empty() && mCache.mPositionFailure.back().equals(s)) {
- mCache.mPositionFailure.back().mUtcReported = s.mUtcReported;
- } else {
- mCache.mPositionFailure.push_back(s);
- if (mCache.mPositionFailure.size() > maxPositionFailure) {
- mCache.mPositionFailure.erase(mCache.mPositionFailure.begin());
- }
- }
- return true;
-}
-
-/******************************************************************************
- SystemStatus - storing dataitems
-******************************************************************************/
-bool SystemStatus::setNetworkInfo(IDataItemCore* dataitem)
-{
- SystemStatusNetworkInfo* data = reinterpret_cast<SystemStatusNetworkInfo*>(dataitem);
- SystemStatusNetworkInfo s(data->mType,data->mTypeName,data->mSubTypeName,
- data->mAvailable,data->mConnected,data->mRoaming);
- s.dump();
- mConnected = data->mConnected;
-
- if (!mCache.mNetworkInfo.empty() && mCache.mNetworkInfo.back().equals(s)) {
- mCache.mNetworkInfo.back().mUtcReported = s.mUtcReported;
- } else {
- mCache.mNetworkInfo.push_back(s);
- if (mCache.mNetworkInfo.size() > maxNetworkInfo) {
- mCache.mNetworkInfo.erase(mCache.mNetworkInfo.begin());
- }
- }
- return true;
}
/******************************************************************************
@@ -1445,17 +1319,6 @@ bool SystemStatus::setNetworkInfo(IDataItemCore* dataitem)
@return true when successfully done
******************************************************************************/
-static uint32_t cnt = 0;
-static uint32_t cnt_m1 = 0;
-static uint32_t cnt_p1 = 0;
-static uint32_t cnt_p2 = 0;
-static uint32_t cnt_p3 = 0;
-static uint32_t cnt_p4 = 0;
-static uint32_t cnt_p5 = 0;
-static uint32_t cnt_p6 = 0;
-static uint32_t cnt_p7 = 0;
-static uint32_t cnt_s1 = 0;
-
bool SystemStatus::setNmeaString(const char *data, uint32_t len)
{
bool ret = false;
@@ -1471,59 +1334,46 @@ bool SystemStatus::setNmeaString(const char *data, uint32_t len)
// parse the received nmea strings here
if (0 == strncmp(data, "$PQWM1", SystemStatusNmeaBase::NMEA_MINSIZE)) {
SystemStatusPQWM1 s = SystemStatusPQWM1parser(buf, len).get();
- ret = setTimeAndCLock(s);
- ret |= setXoState(s);
- ret |= setRfAndParams(s);
- ret |= setErrRecovery(s);
- cnt_m1++;
+ ret |= setIteminReport(mCache.mTimeAndClock, SystemStatusTimeAndClock(s));
+ ret |= setIteminReport(mCache.mXoState, SystemStatusXoState(s));
+ ret |= setIteminReport(mCache.mRfAndParams, SystemStatusRfAndParams(s));
+ ret |= setIteminReport(mCache.mErrRecovery, SystemStatusErrRecovery(s));
}
else if (0 == strncmp(data, "$PQWP1", SystemStatusNmeaBase::NMEA_MINSIZE)) {
- ret = setInjectedPosition(SystemStatusPQWP1parser(buf, len).get());
- cnt_p1++;
+ ret = setIteminReport(mCache.mInjectedPosition,
+ SystemStatusInjectedPosition(SystemStatusPQWP1parser(buf, len).get()));
}
else if (0 == strncmp(data, "$PQWP2", SystemStatusNmeaBase::NMEA_MINSIZE)) {
- ret = setBestPosition(SystemStatusPQWP2parser(buf, len).get());
- cnt_p2++;
+ ret = setIteminReport(mCache.mBestPosition,
+ SystemStatusBestPosition(SystemStatusPQWP2parser(buf, len).get()));
}
else if (0 == strncmp(data, "$PQWP3", SystemStatusNmeaBase::NMEA_MINSIZE)) {
- ret = setXtra(SystemStatusPQWP3parser(buf, len).get());
- cnt_p3++;
+ ret = setIteminReport(mCache.mXtra,
+ SystemStatusXtra(SystemStatusPQWP3parser(buf, len).get()));
}
else if (0 == strncmp(data, "$PQWP4", SystemStatusNmeaBase::NMEA_MINSIZE)) {
- ret = setEphemeris(SystemStatusPQWP4parser(buf, len).get());
- cnt_p4++;
+ ret = setIteminReport(mCache.mEphemeris,
+ SystemStatusEphemeris(SystemStatusPQWP4parser(buf, len).get()));
}
else if (0 == strncmp(data, "$PQWP5", SystemStatusNmeaBase::NMEA_MINSIZE)) {
- ret = setSvHealth(SystemStatusPQWP5parser(buf, len).get());
- cnt_p5++;
+ ret = setIteminReport(mCache.mSvHealth,
+ SystemStatusSvHealth(SystemStatusPQWP5parser(buf, len).get()));
}
else if (0 == strncmp(data, "$PQWP6", SystemStatusNmeaBase::NMEA_MINSIZE)) {
- ret = setPdr(SystemStatusPQWP6parser(buf, len).get());
- cnt_p6++;
+ ret = setIteminReport(mCache.mPdr,
+ SystemStatusPdr(SystemStatusPQWP6parser(buf, len).get()));
}
else if (0 == strncmp(data, "$PQWP7", SystemStatusNmeaBase::NMEA_MINSIZE)) {
- ret = setNavData(SystemStatusPQWP7parser(buf, len).get());
- cnt_p7++;
+ ret = setIteminReport(mCache.mNavData,
+ SystemStatusNavData(SystemStatusPQWP7parser(buf, len).get()));
}
else if (0 == strncmp(data, "$PQWS1", SystemStatusNmeaBase::NMEA_MINSIZE)) {
- ret = setPositionFailure(SystemStatusPQWS1parser(buf, len).get());
- cnt_s1++;
+ ret = setIteminReport(mCache.mPositionFailure,
+ SystemStatusPositionFailure(SystemStatusPQWS1parser(buf, len).get()));
}
else {
// do nothing
}
- cnt++;
- LOC_LOGV("setNmeaString: cnt=%d M:%d 1:%d 2:%d 3:%d 4:%d 5:%d 6:%d 7:%d S:%d",
- cnt,
- cnt_m1,
- cnt_p1,
- cnt_p2,
- cnt_p3,
- cnt_p4,
- cnt_p5,
- cnt_p6,
- cnt_p7,
- cnt_s1);
pthread_mutex_unlock(&mMutexSystemStatus);
return ret;
@@ -1539,22 +1389,18 @@ bool SystemStatus::setNmeaString(const char *data, uint32_t len)
bool SystemStatus::eventPosition(const UlpLocation& location,
const GpsLocationExtended& locationEx)
{
- SystemStatusLocation s(location, locationEx);
- if (!mCache.mLocation.empty() && mCache.mLocation.back().equals(s)) {
- mCache.mLocation.back().mUtcReported = s.mUtcReported;
- }
- else {
- mCache.mLocation.push_back(s);
- if (mCache.mLocation.size() > maxLocation) {
- mCache.mLocation.erase(mCache.mLocation.begin());
- }
- }
+ bool ret = false;
+ pthread_mutex_lock(&mMutexSystemStatus);
+
+ ret = setIteminReport(mCache.mLocation, SystemStatusLocation(location, locationEx));
LOC_LOGV("eventPosition - lat=%f lon=%f alt=%f speed=%f",
- s.mLocation.gpsLocation.latitude,
- s.mLocation.gpsLocation.longitude,
- s.mLocation.gpsLocation.altitude,
- s.mLocation.gpsLocation.speed);
- return true;
+ location.gpsLocation.latitude,
+ location.gpsLocation.longitude,
+ location.gpsLocation.altitude,
+ location.gpsLocation.speed);
+
+ pthread_mutex_unlock(&mMutexSystemStatus);
+ return ret;
}
/******************************************************************************
@@ -1562,19 +1408,109 @@ bool SystemStatus::eventPosition(const UlpLocation& location,
@param[In] DataItem
-@return true when successfully done
+@return true when info is updatated
******************************************************************************/
bool SystemStatus::eventDataItemNotify(IDataItemCore* dataitem)
{
+ bool ret = false;
pthread_mutex_lock(&mMutexSystemStatus);
switch(dataitem->getId())
{
+ case AIRPLANEMODE_DATA_ITEM_ID:
+ ret = setItemBaseinReport<SystemStatusAirplaneMode>(mCache.mAirplaneMode,
+ *(static_cast<AirplaneModeDataItemBase*>(dataitem)));
+ break;
+ case ENH_DATA_ITEM_ID:
+ ret = setItemBaseinReport<SystemStatusENH>(mCache.mENH,
+ *(static_cast<ENHDataItemBase*>(dataitem)));
+ break;
+ case GPSSTATE_DATA_ITEM_ID:
+ ret = setItemBaseinReport<SystemStatusGpsState>(mCache.mGPSState,
+ *(static_cast<GPSStateDataItemBase*>(dataitem)));
+ break;
+ case NLPSTATUS_DATA_ITEM_ID:
+ ret = setItemBaseinReport<SystemStatusNLPStatus>(mCache.mNLPStatus,
+ *(static_cast<NLPStatusDataItemBase*>(dataitem)));
+ break;
+ case WIFIHARDWARESTATE_DATA_ITEM_ID:
+ ret = setItemBaseinReport<SystemStatusWifiHardwareState>(mCache.mWifiHardwareState,
+ *(static_cast<WifiHardwareStateDataItemBase*>(dataitem)));
+ break;
case NETWORKINFO_DATA_ITEM_ID:
- setNetworkInfo(dataitem);
+ ret = setItemBaseinReport<SystemStatusNetworkInfo>(mCache.mNetworkInfo,
+ *(static_cast<NetworkInfoDataItemBase*>(dataitem)));
+ break;
+ case RILSERVICEINFO_DATA_ITEM_ID:
+ ret = setItemBaseinReport<SystemStatusServiceInfo>(mCache.mRilServiceInfo,
+ *(static_cast<RilServiceInfoDataItemBase*>(dataitem)));
+ break;
+ case RILCELLINFO_DATA_ITEM_ID:
+ ret = setItemBaseinReport<SystemStatusRilCellInfo>(mCache.mRilCellInfo,
+ *(static_cast<RilCellInfoDataItemBase*>(dataitem)));
+ break;
+ case SERVICESTATUS_DATA_ITEM_ID:
+ ret = setItemBaseinReport<SystemStatusServiceStatus>(mCache.mServiceStatus,
+ *(static_cast<ServiceStatusDataItemBase*>(dataitem)));
+ break;
+ case MODEL_DATA_ITEM_ID:
+ ret = setItemBaseinReport<SystemStatusModel>(mCache.mModel,
+ *(static_cast<ModelDataItemBase*>(dataitem)));
+ break;
+ case MANUFACTURER_DATA_ITEM_ID:
+ ret = setItemBaseinReport<SystemStatusManufacturer>(mCache.mManufacturer,
+ *(static_cast<ManufacturerDataItemBase*>(dataitem)));
+ break;
+ case ASSISTED_GPS_DATA_ITEM_ID:
+ ret = setItemBaseinReport<SystemStatusAssistedGps>(mCache.mAssistedGps,
+ *(static_cast<AssistedGpsDataItemBase*>(dataitem)));
+ break;
+ case SCREEN_STATE_DATA_ITEM_ID:
+ ret = setItemBaseinReport<SystemStatusScreenState>(mCache.mScreenState,
+ *(static_cast<ScreenStateDataItemBase*>(dataitem)));
+ break;
+ case POWER_CONNECTED_STATE_DATA_ITEM_ID:
+ ret = setItemBaseinReport<SystemStatusPowerConnectState>(mCache.mPowerConnectState,
+ *(static_cast<PowerConnectStateDataItemBase*>(dataitem)));
+ break;
+ case TIMEZONE_CHANGE_DATA_ITEM_ID:
+ ret = setItemBaseinReport<SystemStatusTimeZoneChange>(mCache.mTimeZoneChange,
+ *(static_cast<TimeZoneChangeDataItemBase*>(dataitem)));
+ break;
+ case TIME_CHANGE_DATA_ITEM_ID:
+ ret = setItemBaseinReport<SystemStatusTimeChange>(mCache.mTimeChange,
+ *(static_cast<TimeChangeDataItemBase*>(dataitem)));
+ break;
+ case WIFI_SUPPLICANT_STATUS_DATA_ITEM_ID:
+ ret = setItemBaseinReport<SystemStatusWifiSupplicantStatus>(
+ mCache.mWifiSupplicantStatus,
+ *(static_cast<WifiSupplicantStatusDataItemBase*>(dataitem)));
+ break;
+ case SHUTDOWN_STATE_DATA_ITEM_ID:
+ ret = setItemBaseinReport<SystemStatusShutdownState>(mCache.mShutdownState,
+ *(static_cast<ShutdownStateDataItemBase*>(dataitem)));
+ break;
+ case TAC_DATA_ITEM_ID:
+ ret = setItemBaseinReport<SystemStatusTac>(mCache.mTac,
+ *(static_cast<TacDataItemBase*>(dataitem)));
+ break;
+ case MCCMNC_DATA_ITEM_ID:
+ ret = setItemBaseinReport<SystemStatusMccMnc>(mCache.mMccMnc,
+ *(static_cast<MccmncDataItemBase*>(dataitem)));
+ break;
+ case BTLE_SCAN_DATA_ITEM_ID:
+ ret = setItemBaseinReport<SystemStatusBtDeviceScanDetail>(mCache.mBtDeviceScanDetail,
+ *(static_cast<BtDeviceScanDetailsDataItemBase*>(dataitem)));
+ break;
+ case BT_SCAN_DATA_ITEM_ID:
+ ret = setItemBaseinReport<SystemStatusBtleDeviceScanDetail>(
+ mCache.mBtLeDeviceScanDetail,
+ *(static_cast<BtLeDeviceScanDetailsDataItemBase*>(dataitem)));
+ break;
+ default:
break;
}
pthread_mutex_unlock(&mMutexSystemStatus);
- return true;
+ return ret;
}
/******************************************************************************
@@ -1591,74 +1527,45 @@ bool SystemStatus::getReport(SystemStatusReports& report, bool isLatestOnly) con
if (isLatestOnly) {
// push back only the latest report and return it
- report.mLocation.clear();
- if (mCache.mLocation.size() >= 1) {
- report.mLocation.push_back(mCache.mLocation.back());
- report.mLocation.back().dump();
- }
-
- report.mTimeAndClock.clear();
- if (mCache.mTimeAndClock.size() >= 1) {
- report.mTimeAndClock.push_back(mCache.mTimeAndClock.back());
- report.mTimeAndClock.back().dump();
- }
- report.mXoState.clear();
- if (mCache.mXoState.size() >= 1) {
- report.mXoState.push_back(mCache.mXoState.back());
- report.mXoState.back().dump();
- }
- report.mRfAndParams.clear();
- if (mCache.mRfAndParams.size() >= 1) {
- report.mRfAndParams.push_back(mCache.mRfAndParams.back());
- report.mRfAndParams.back().dump();
- }
- report.mErrRecovery.clear();
- if (mCache.mErrRecovery.size() >= 1) {
- report.mErrRecovery.push_back(mCache.mErrRecovery.back());
- report.mErrRecovery.back().dump();
- }
-
- report.mInjectedPosition.clear();
- if (mCache.mInjectedPosition.size() >= 1) {
- report.mInjectedPosition.push_back(mCache.mInjectedPosition.back());
- report.mInjectedPosition.back().dump();
- }
- report.mBestPosition.clear();
- if (mCache.mBestPosition.size() >= 1) {
- report.mBestPosition.push_back(mCache.mBestPosition.back());
- report.mBestPosition.back().dump();
- }
- report.mXtra.clear();
- if (mCache.mXtra.size() >= 1) {
- report.mXtra.push_back(mCache.mXtra.back());
- report.mXtra.back().dump();
- }
- report.mEphemeris.clear();
- if (mCache.mEphemeris.size() >= 1) {
- report.mEphemeris.push_back(mCache.mEphemeris.back());
- report.mEphemeris.back().dump();
- }
- report.mSvHealth.clear();
- if (mCache.mSvHealth.size() >= 1) {
- report.mSvHealth.push_back(mCache.mSvHealth.back());
- report.mSvHealth.back().dump();
- }
- report.mPdr.clear();
- if (mCache.mPdr.size() >= 1) {
- report.mPdr.push_back(mCache.mPdr.back());
- report.mPdr.back().dump();
- }
- report.mNavData.clear();
- if (mCache.mNavData.size() >= 1) {
- report.mNavData.push_back(mCache.mNavData.back());
- report.mNavData.back().dump();
- }
-
- report.mPositionFailure.clear();
- if (mCache.mPositionFailure.size() >= 1) {
- report.mPositionFailure.push_back(mCache.mPositionFailure.back());
- report.mPositionFailure.back().dump();
- }
+ getIteminReport(report.mLocation, mCache.mLocation);
+
+ getIteminReport(report.mTimeAndClock, mCache.mTimeAndClock);
+ getIteminReport(report.mXoState, mCache.mXoState);
+ getIteminReport(report.mRfAndParams, mCache.mRfAndParams);
+ getIteminReport(report.mErrRecovery, mCache.mErrRecovery);
+
+ getIteminReport(report.mInjectedPosition, mCache.mInjectedPosition);
+ getIteminReport(report.mBestPosition, mCache.mBestPosition);
+ getIteminReport(report.mXtra, mCache.mXtra);
+ getIteminReport(report.mEphemeris, mCache.mEphemeris);
+ getIteminReport(report.mSvHealth, mCache.mSvHealth);
+ getIteminReport(report.mPdr, mCache.mPdr);
+ getIteminReport(report.mNavData, mCache.mNavData);
+
+ getIteminReport(report.mPositionFailure, mCache.mPositionFailure);
+
+ getIteminReport(report.mAirplaneMode, mCache.mAirplaneMode);
+ getIteminReport(report.mENH, mCache.mENH);
+ getIteminReport(report.mGPSState, mCache.mGPSState);
+ getIteminReport(report.mNLPStatus, mCache.mNLPStatus);
+ getIteminReport(report.mWifiHardwareState, mCache.mWifiHardwareState);
+ getIteminReport(report.mNetworkInfo, mCache.mNetworkInfo);
+ getIteminReport(report.mRilServiceInfo, mCache.mRilServiceInfo);
+ getIteminReport(report.mRilCellInfo, mCache.mRilCellInfo);
+ getIteminReport(report.mServiceStatus, mCache.mServiceStatus);
+ getIteminReport(report.mModel, mCache.mModel);
+ getIteminReport(report.mManufacturer, mCache.mManufacturer);
+ getIteminReport(report.mAssistedGps, mCache.mAssistedGps);
+ getIteminReport(report.mScreenState, mCache.mScreenState);
+ getIteminReport(report.mPowerConnectState, mCache.mPowerConnectState);
+ getIteminReport(report.mTimeZoneChange, mCache.mTimeZoneChange);
+ getIteminReport(report.mTimeChange, mCache.mTimeChange);
+ getIteminReport(report.mWifiSupplicantStatus, mCache.mWifiSupplicantStatus);
+ getIteminReport(report.mShutdownState, mCache.mShutdownState);
+ getIteminReport(report.mTac, mCache.mTac);
+ getIteminReport(report.mMccMnc, mCache.mMccMnc);
+ getIteminReport(report.mBtDeviceScanDetail, mCache.mBtDeviceScanDetail);
+ getIteminReport(report.mBtLeDeviceScanDetail, mCache.mBtLeDeviceScanDetail);
}
else {
// copy entire reports and return them
@@ -1678,6 +1585,30 @@ bool SystemStatus::getReport(SystemStatusReports& report, bool isLatestOnly) con
report.mNavData.clear();
report.mPositionFailure.clear();
+
+ report.mAirplaneMode.clear();
+ report.mENH.clear();
+ report.mGPSState.clear();
+ report.mNLPStatus.clear();
+ report.mWifiHardwareState.clear();
+ report.mNetworkInfo.clear();
+ report.mRilServiceInfo.clear();
+ report.mRilCellInfo.clear();
+ report.mServiceStatus.clear();
+ report.mModel.clear();
+ report.mManufacturer.clear();
+ report.mAssistedGps.clear();
+ report.mScreenState.clear();
+ report.mPowerConnectState.clear();
+ report.mTimeZoneChange.clear();
+ report.mTimeChange.clear();
+ report.mWifiSupplicantStatus.clear();
+ report.mShutdownState.clear();
+ report.mTac.clear();
+ report.mMccMnc.clear();
+ report.mBtDeviceScanDetail.clear();
+ report.mBtLeDeviceScanDetail.clear();
+
report = mCache;
}
@@ -1696,61 +1627,45 @@ bool SystemStatus::setDefaultReport(void)
{
pthread_mutex_lock(&mMutexSystemStatus);
- mCache.mLocation.push_back(SystemStatusLocation());
- if (mCache.mLocation.size() > maxLocation) {
- mCache.mLocation.erase(mCache.mLocation.begin());
- }
-
- mCache.mTimeAndClock.push_back(SystemStatusTimeAndClock());
- if (mCache.mTimeAndClock.size() > maxTimeAndClock) {
- mCache.mTimeAndClock.erase(mCache.mTimeAndClock.begin());
- }
- mCache.mXoState.push_back(SystemStatusXoState());
- if (mCache.mXoState.size() > maxXoState) {
- mCache.mXoState.erase(mCache.mXoState.begin());
- }
- mCache.mRfAndParams.push_back(SystemStatusRfAndParams());
- if (mCache.mRfAndParams.size() > maxRfAndParams) {
- mCache.mRfAndParams.erase(mCache.mRfAndParams.begin());
- }
- mCache.mErrRecovery.push_back(SystemStatusErrRecovery());
- if (mCache.mErrRecovery.size() > maxErrRecovery) {
- mCache.mErrRecovery.erase(mCache.mErrRecovery.begin());
- }
-
- mCache.mInjectedPosition.push_back(SystemStatusInjectedPosition());
- if (mCache.mInjectedPosition.size() > maxInjectedPosition) {
- mCache.mInjectedPosition.erase(mCache.mInjectedPosition.begin());
- }
- mCache.mBestPosition.push_back(SystemStatusBestPosition());
- if (mCache.mBestPosition.size() > maxBestPosition) {
- mCache.mBestPosition.erase(mCache.mBestPosition.begin());
- }
- mCache.mXtra.push_back(SystemStatusXtra());
- if (mCache.mXtra.size() > maxXtra) {
- mCache.mXtra.erase(mCache.mXtra.begin());
- }
- mCache.mEphemeris.push_back(SystemStatusEphemeris());
- if (mCache.mEphemeris.size() > maxEphemeris) {
- mCache.mEphemeris.erase(mCache.mEphemeris.begin());
- }
- mCache.mSvHealth.push_back(SystemStatusSvHealth());
- if (mCache.mSvHealth.size() > maxSvHealth) {
- mCache.mSvHealth.erase(mCache.mSvHealth.begin());
- }
- mCache.mPdr.push_back(SystemStatusPdr());
- if (mCache.mPdr.size() > maxPdr) {
- mCache.mPdr.erase(mCache.mPdr.begin());
- }
- mCache.mNavData.push_back(SystemStatusNavData());
- if (mCache.mNavData.size() > maxNavData) {
- mCache.mNavData.erase(mCache.mNavData.begin());
- }
-
- mCache.mPositionFailure.push_back(SystemStatusPositionFailure());
- if (mCache.mPositionFailure.size() > maxPositionFailure) {
- mCache.mPositionFailure.erase(mCache.mPositionFailure.begin());
- }
+ setDefaultIteminReport(mCache.mLocation, SystemStatusLocation());
+
+ setDefaultIteminReport(mCache.mTimeAndClock, SystemStatusTimeAndClock());
+ setDefaultIteminReport(mCache.mXoState, SystemStatusXoState());
+ setDefaultIteminReport(mCache.mRfAndParams, SystemStatusRfAndParams());
+ setDefaultIteminReport(mCache.mErrRecovery, SystemStatusErrRecovery());
+
+ setDefaultIteminReport(mCache.mInjectedPosition, SystemStatusInjectedPosition());
+ setDefaultIteminReport(mCache.mBestPosition, SystemStatusBestPosition());
+ setDefaultIteminReport(mCache.mXtra, SystemStatusXtra());
+ setDefaultIteminReport(mCache.mEphemeris, SystemStatusEphemeris());
+ setDefaultIteminReport(mCache.mSvHealth, SystemStatusSvHealth());
+ setDefaultIteminReport(mCache.mPdr, SystemStatusPdr());
+ setDefaultIteminReport(mCache.mNavData, SystemStatusNavData());
+
+ setDefaultIteminReport(mCache.mPositionFailure, SystemStatusPositionFailure());
+
+ setDefaultIteminReport(mCache.mAirplaneMode, SystemStatusAirplaneMode());
+ setDefaultIteminReport(mCache.mENH, SystemStatusENH());
+ setDefaultIteminReport(mCache.mGPSState, SystemStatusGpsState());
+ setDefaultIteminReport(mCache.mNLPStatus, SystemStatusNLPStatus());
+ setDefaultIteminReport(mCache.mWifiHardwareState, SystemStatusWifiHardwareState());
+ setDefaultIteminReport(mCache.mNetworkInfo, SystemStatusNetworkInfo());
+ setDefaultIteminReport(mCache.mRilServiceInfo, SystemStatusServiceInfo());
+ setDefaultIteminReport(mCache.mRilCellInfo, SystemStatusRilCellInfo());
+ setDefaultIteminReport(mCache.mServiceStatus, SystemStatusServiceStatus());
+ setDefaultIteminReport(mCache.mModel, SystemStatusModel());
+ setDefaultIteminReport(mCache.mManufacturer, SystemStatusManufacturer());
+ setDefaultIteminReport(mCache.mAssistedGps, SystemStatusAssistedGps());
+ setDefaultIteminReport(mCache.mScreenState, SystemStatusScreenState());
+ setDefaultIteminReport(mCache.mPowerConnectState, SystemStatusPowerConnectState());
+ setDefaultIteminReport(mCache.mTimeZoneChange, SystemStatusTimeZoneChange());
+ setDefaultIteminReport(mCache.mTimeChange, SystemStatusTimeChange());
+ setDefaultIteminReport(mCache.mWifiSupplicantStatus, SystemStatusWifiSupplicantStatus());
+ setDefaultIteminReport(mCache.mShutdownState, SystemStatusShutdownState());
+ setDefaultIteminReport(mCache.mTac, SystemStatusTac());
+ setDefaultIteminReport(mCache.mMccMnc, SystemStatusMccMnc());
+ setDefaultIteminReport(mCache.mBtDeviceScanDetail, SystemStatusBtDeviceScanDetail());
+ setDefaultIteminReport(mCache.mBtLeDeviceScanDetail, SystemStatusBtleDeviceScanDetail());
pthread_mutex_unlock(&mMutexSystemStatus);
return true;
@@ -1770,15 +1685,8 @@ bool SystemStatus::eventConnectionStatus(bool connected, uint8_t type)
// send networkinof dataitem to systemstatus observer clients
SystemStatusNetworkInfo s(type, "", "", false, connected, false);
- IDataItemCore *networkinfo =
- DataItemsFactoryProxy::createNewDataItem(NETWORKINFO_DATA_ITEM_ID);
- if (nullptr == networkinfo) {
- LOC_LOGE("Unable to create dataitemd");
- return false;
- }
- networkinfo->copy(&s);
list<IDataItemCore*> dl(0);
- dl.push_back(networkinfo);
+ dl.push_back(&s);
mSysStatusObsvr.notify(dl);
}
return true;
diff --git a/gps/core/SystemStatus.h b/gps/core/SystemStatus.h
index 5dc2d9f..1bcef10 100644
--- a/gps/core/SystemStatus.h
+++ b/gps/core/SystemStatus.h
@@ -36,6 +36,7 @@
#include <MsgTask.h>
#include <IDataItemCore.h>
#include <IOsObserver.h>
+#include <DataItemConcreteTypesBase.h>
#include <SystemStatusOsObserver.h>
#include <gps_extended_c.h>
@@ -66,6 +67,7 @@ class SystemStatusItemBase
public:
timespec mUtcTime; // UTC timestamp when this info was last updated
timespec mUtcReported; // UTC timestamp when this info was reported
+ static const uint32_t maxItem = 5;
SystemStatusItemBase() {
timeval tv;
@@ -91,7 +93,7 @@ public:
mValid(true),
mLocation(location),
mLocationEx(locationEx) { }
- bool equals(SystemStatusLocation& peer);
+ bool equals(const SystemStatusLocation& peer);
void dump(void);
};
@@ -119,7 +121,7 @@ public:
mLeapSeconds(0),
mLeapSecUnc(0) {}
inline SystemStatusTimeAndClock(const SystemStatusPQWM1& nmea);
- bool equals(SystemStatusTimeAndClock& peer);
+ bool equals(const SystemStatusTimeAndClock& peer);
void dump(void);
};
@@ -130,7 +132,7 @@ public:
inline SystemStatusXoState() :
mXoState(0) {}
inline SystemStatusXoState(const SystemStatusPQWM1& nmea);
- bool equals(SystemStatusXoState& peer);
+ bool equals(const SystemStatusXoState& peer);
void dump(void);
};
@@ -165,7 +167,7 @@ public:
mAgcBds(0),
mAgcGal(0) {}
inline SystemStatusRfAndParams(const SystemStatusPQWM1& nmea);
- bool equals(SystemStatusRfAndParams& peer);
+ bool equals(const SystemStatusRfAndParams& peer);
void dump(void);
};
@@ -176,7 +178,7 @@ public:
inline SystemStatusErrRecovery() :
mRecErrorRecovery(0) {};
inline SystemStatusErrRecovery(const SystemStatusPQWM1& nmea);
- bool equals(SystemStatusErrRecovery& peer);
+ bool equals(const SystemStatusErrRecovery& peer);
void dump(void);
};
@@ -200,7 +202,7 @@ public:
mEpiAltUnc(0),
mEpiSrc(0) {}
inline SystemStatusInjectedPosition(const SystemStatusPQWP1& nmea);
- bool equals(SystemStatusInjectedPosition& peer);
+ bool equals(const SystemStatusInjectedPosition& peer);
void dump(void);
};
@@ -222,7 +224,7 @@ public:
mBestHepe(0),
mBestAltUnc(0) {}
inline SystemStatusBestPosition(const SystemStatusPQWP2& nmea);
- bool equals(SystemStatusBestPosition& peer);
+ bool equals(const SystemStatusBestPosition& peer);
void dump(void);
};
@@ -254,7 +256,7 @@ public:
mGalXtraValid(0ULL),
mQzssXtraValid(0) {}
inline SystemStatusXtra(const SystemStatusPQWP3& nmea);
- bool equals(SystemStatusXtra& peer);
+ bool equals(const SystemStatusXtra& peer);
void dump(void);
};
@@ -274,7 +276,7 @@ public:
mGalEpheValid(0ULL),
mQzssEpheValid(0) {}
inline SystemStatusEphemeris(const SystemStatusPQWP4& nmea);
- bool equals(SystemStatusEphemeris& peer);
+ bool equals(const SystemStatusEphemeris& peer);
void dump(void);
};
@@ -314,7 +316,7 @@ public:
mGalBadMask(0ULL),
mQzssBadMask(0) {}
inline SystemStatusSvHealth(const SystemStatusPQWP5& nmea);
- bool equals(SystemStatusSvHealth& peer);
+ bool equals(const SystemStatusSvHealth& peer);
void dump(void);
};
@@ -326,7 +328,7 @@ public:
inline SystemStatusPdr() :
mFixInfoMask(0) {}
inline SystemStatusPdr(const SystemStatusPQWP6& nmea);
- bool equals(SystemStatusPdr& peer);
+ bool equals(const SystemStatusPdr& peer);
void dump(void);
};
@@ -350,7 +352,7 @@ public:
}
}
inline SystemStatusNavData(const SystemStatusPQWP7& nmea);
- bool equals(SystemStatusNavData& peer);
+ bool equals(const SystemStatusNavData& peer);
void dump(void);
};
@@ -364,168 +366,339 @@ public:
mFixInfoMask(0),
mHepeLimit(0) {}
inline SystemStatusPositionFailure(const SystemStatusPQWS1& nmea);
- bool equals(SystemStatusPositionFailure& peer);
+ bool equals(const SystemStatusPositionFailure& peer);
void dump(void);
};
/******************************************************************************
SystemStatus report data structure - from DataItem observer
******************************************************************************/
-class SystemStatusGpsState : public SystemStatusItemBase, public IDataItemCore
+class SystemStatusAirplaneMode : public SystemStatusItemBase,
+ public AirplaneModeDataItemBase
{
public:
- inline SystemStatusGpsState() :
- mEnabled(false) {}
- inline SystemStatusGpsState(bool enabled) :
- mEnabled(enabled) {}
+ inline SystemStatusAirplaneMode(bool mode=false) :
+ AirplaneModeDataItemBase(mode) {}
+ inline SystemStatusAirplaneMode(const AirplaneModeDataItemBase& itemBase) :
+ AirplaneModeDataItemBase(itemBase) {}
+ inline bool equals(const SystemStatusAirplaneMode& peer) {
+ return (mMode == peer.mMode);
+ }
+};
- bool mEnabled;
+class SystemStatusENH : public SystemStatusItemBase,
+ public ENHDataItemBase
+{
+public:
+ inline SystemStatusENH(bool enabled=false) :
+ ENHDataItemBase(enabled) {}
+ inline SystemStatusENH(const ENHDataItemBase& itemBase) :
+ ENHDataItemBase(itemBase) {}
+ inline bool equals(const SystemStatusENH& peer) {
+ return (mEnabled == peer.mEnabled);
+ }
+};
- inline bool equals(SystemStatusGpsState& peer) {
+class SystemStatusGpsState : public SystemStatusItemBase,
+ public GPSStateDataItemBase
+{
+public:
+ inline SystemStatusGpsState(bool enabled=false) :
+ GPSStateDataItemBase(enabled) {}
+ inline SystemStatusGpsState(const GPSStateDataItemBase& itemBase) :
+ GPSStateDataItemBase(itemBase) {}
+ inline bool equals(const SystemStatusGpsState& peer) {
return (mEnabled == peer.mEnabled);
}
- inline void dump(void) {
+ inline void dump(void) override {
LOC_LOGD("GpsState: state=%u", mEnabled);
}
- inline DataItemId getId() {
- return GPSSTATE_DATA_ITEM_ID;
- }
- inline void stringify(string& valueStr) {
- valueStr.clear();
- valueStr += "GpsState: enabled=";
- valueStr += to_string(mEnabled);
+};
+
+class SystemStatusNLPStatus : public SystemStatusItemBase,
+ public NLPStatusDataItemBase
+{
+public:
+ inline SystemStatusNLPStatus(bool enabled=false) :
+ NLPStatusDataItemBase(enabled) {}
+ inline SystemStatusNLPStatus(const NLPStatusDataItemBase& itemBase) :
+ NLPStatusDataItemBase(itemBase) {}
+ inline bool equals(const SystemStatusNLPStatus& peer) {
+ return (mEnabled == peer.mEnabled);
}
- inline int32_t copy(IDataItemCore* src, bool* dataItemCopied = nullptr) {
- SystemStatusGpsState* gpsstate = static_cast<SystemStatusGpsState*>(src);
- mEnabled = gpsstate->mEnabled;
- if (dataItemCopied) {
- *dataItemCopied = true;
- }
- return 1;
+};
+
+class SystemStatusWifiHardwareState : public SystemStatusItemBase,
+ public WifiHardwareStateDataItemBase
+{
+public:
+ inline SystemStatusWifiHardwareState(bool enabled=false) :
+ WifiHardwareStateDataItemBase(enabled) {}
+ inline SystemStatusWifiHardwareState(const WifiHardwareStateDataItemBase& itemBase) :
+ WifiHardwareStateDataItemBase(itemBase) {}
+ inline bool equals(const SystemStatusWifiHardwareState& peer) {
+ return (mEnabled == peer.mEnabled);
}
};
-class SystemStatusNetworkInfo : public SystemStatusItemBase, public IDataItemCore
+class SystemStatusNetworkInfo : public SystemStatusItemBase,
+ public NetworkInfoDataItemBase
{
public:
- inline SystemStatusNetworkInfo() :
- mType(0),
- mTypeName(""),
- mSubTypeName(""),
- mAvailable(false),
- mConnected(false),
- mRoaming(false) {}
inline SystemStatusNetworkInfo(
- uint32_t type,
- std::string typeName,
- std::string subTypeName,
- bool available,
- bool connected,
- bool roaming) :
- mType(type),
- mTypeName(typeName),
- mSubTypeName(subTypeName),
- mAvailable(available),
- mConnected(connected),
- mRoaming(roaming) {}
-
- uint32_t mType;
- std::string mTypeName;
- std::string mSubTypeName;
- bool mAvailable;
- bool mConnected;
- bool mRoaming;
-
- inline bool equals(SystemStatusNetworkInfo& peer) {
- if ((mType != peer.mType) ||
- (mTypeName != peer.mTypeName) ||
- (mSubTypeName != peer.mSubTypeName) ||
- (mAvailable != peer.mAvailable) ||
- (mConnected != peer.mConnected) ||
- (mRoaming != peer.mRoaming)) {
- return false;
+ int32_t type=0,
+ std::string typeName="",
+ string subTypeName="",
+ bool available=false,
+ bool connected=false,
+ bool roaming=false) :
+ NetworkInfoDataItemBase(
+ type,
+ typeName,
+ subTypeName,
+ available,
+ connected,
+ roaming) {}
+ inline SystemStatusNetworkInfo(const NetworkInfoDataItemBase& itemBase) :
+ NetworkInfoDataItemBase(itemBase) {
+ mType = itemBase.getType();
+ }
+ inline bool equals(const SystemStatusNetworkInfo& peer) {
+ if ((mType == peer.mType) &&
+ (mTypeName == peer.mTypeName) &&
+ (mSubTypeName == peer.mSubTypeName) &&
+ (mAvailable == peer.mAvailable) &&
+ (mConnected == peer.mConnected) &&
+ (mRoaming == peer.mRoaming)) {
+ return true;
}
- return true;
+ return false;
}
- inline void dump(void) {
+ inline void dump(void) override {
LOC_LOGD("NetworkInfo: type=%u connected=%u", mType, mConnected);
}
- inline DataItemId getId() {
- return NETWORKINFO_DATA_ITEM_ID;
+};
+
+class SystemStatusServiceInfo : public SystemStatusItemBase,
+ public RilServiceInfoDataItemBase
+{
+public:
+ inline SystemStatusServiceInfo() :
+ RilServiceInfoDataItemBase() {}
+ inline SystemStatusServiceInfo(const RilServiceInfoDataItemBase& itemBase) :
+ RilServiceInfoDataItemBase(itemBase) {}
+ inline bool equals(const SystemStatusServiceInfo& /*peer*/) {
+ return true;
+ }
+};
+
+class SystemStatusRilCellInfo : public SystemStatusItemBase,
+ public RilCellInfoDataItemBase
+{
+public:
+ inline SystemStatusRilCellInfo() :
+ RilCellInfoDataItemBase() {}
+ inline SystemStatusRilCellInfo(const RilCellInfoDataItemBase& itemBase) :
+ RilCellInfoDataItemBase(itemBase) {}
+ inline bool equals(const SystemStatusRilCellInfo& /*peer*/) {
+ return true;
+ }
+};
+
+class SystemStatusServiceStatus : public SystemStatusItemBase,
+ public ServiceStatusDataItemBase
+{
+public:
+ inline SystemStatusServiceStatus(int32_t mServiceState=0) :
+ ServiceStatusDataItemBase(mServiceState) {}
+ inline SystemStatusServiceStatus(const ServiceStatusDataItemBase& itemBase) :
+ ServiceStatusDataItemBase(itemBase) {}
+ inline bool equals(const SystemStatusServiceStatus& peer) {
+ return (mServiceState == peer.mServiceState);
}
- inline void stringify(string& /*valueStr*/) { }
- inline int32_t copy(IDataItemCore* src, bool* dataItemCopied = nullptr) {
- SystemStatusNetworkInfo* networkinfo = static_cast<SystemStatusNetworkInfo*>(src);
- mType = networkinfo->mType;
- mTypeName = networkinfo->mTypeName;
- mSubTypeName = networkinfo->mSubTypeName;
- mAvailable = networkinfo->mAvailable;
- mConnected = networkinfo->mConnected;
- mRoaming = networkinfo->mRoaming;
- if (dataItemCopied) {
- *dataItemCopied = true;
+};
+
+class SystemStatusModel : public SystemStatusItemBase,
+ public ModelDataItemBase
+{
+public:
+ inline SystemStatusModel(string name="") :
+ ModelDataItemBase(name) {}
+ inline SystemStatusModel(const ModelDataItemBase& itemBase) :
+ ModelDataItemBase(itemBase) {}
+ inline bool equals(const SystemStatusModel& peer) {
+ return (mModel == peer.mModel);
}
- return 1;
+};
+
+class SystemStatusManufacturer : public SystemStatusItemBase,
+ public ManufacturerDataItemBase
+{
+public:
+ inline SystemStatusManufacturer(string name="") :
+ ManufacturerDataItemBase(name) {}
+ inline SystemStatusManufacturer(const ManufacturerDataItemBase& itemBase) :
+ ManufacturerDataItemBase(itemBase) {}
+ inline bool equals(const SystemStatusManufacturer& peer) {
+ return (mManufacturer == peer.mManufacturer);
}
};
-class SystemStatusTac : public SystemStatusItemBase, public IDataItemCore
+class SystemStatusAssistedGps : public SystemStatusItemBase,
+ public AssistedGpsDataItemBase
{
public:
- inline SystemStatusTac() :
- mValue("") {}
- inline SystemStatusTac(std::string value) :
- mValue(value) {}
+ inline SystemStatusAssistedGps(bool enabled=false) :
+ AssistedGpsDataItemBase(enabled) {}
+ inline SystemStatusAssistedGps(const AssistedGpsDataItemBase& itemBase) :
+ AssistedGpsDataItemBase(itemBase) {}
+ inline bool equals(const SystemStatusAssistedGps& peer) {
+ return (mEnabled == peer.mEnabled);
+ }
+};
- std::string mValue;
+class SystemStatusScreenState : public SystemStatusItemBase,
+ public ScreenStateDataItemBase
+{
+public:
+ inline SystemStatusScreenState(bool state=false) :
+ ScreenStateDataItemBase(state) {}
+ inline SystemStatusScreenState(const ScreenStateDataItemBase& itemBase) :
+ ScreenStateDataItemBase(itemBase) {}
+ inline bool equals(const SystemStatusScreenState& peer) {
+ return (mState == peer.mState);
+ }
+};
- inline bool equals(SystemStatusTac& peer) {
- return (mValue == peer.mValue);
+class SystemStatusPowerConnectState : public SystemStatusItemBase,
+ public PowerConnectStateDataItemBase
+{
+public:
+ inline SystemStatusPowerConnectState(bool state=false) :
+ PowerConnectStateDataItemBase(state) {}
+ inline SystemStatusPowerConnectState(const PowerConnectStateDataItemBase& itemBase) :
+ PowerConnectStateDataItemBase(itemBase) {}
+ inline bool equals(const SystemStatusPowerConnectState& peer) {
+ return (mState == peer.mState);
}
- inline void dump(void) {
- LOC_LOGD("Tac: value=%s", mValue.c_str());
+};
+
+class SystemStatusTimeZoneChange : public SystemStatusItemBase,
+ public TimeZoneChangeDataItemBase
+{
+public:
+ inline SystemStatusTimeZoneChange(
+ int64_t currTimeMillis=0ULL, int32_t rawOffset=0, int32_t dstOffset=0) :
+ TimeZoneChangeDataItemBase(currTimeMillis, rawOffset, dstOffset) {}
+ inline SystemStatusTimeZoneChange(const TimeZoneChangeDataItemBase& itemBase) :
+ TimeZoneChangeDataItemBase(itemBase) {}
+ inline bool equals(const SystemStatusTimeZoneChange& peer) {
+ return ((mCurrTimeMillis == peer.mCurrTimeMillis) &&
+ (mRawOffsetTZ == peer.mRawOffsetTZ) &&
+ (mDstOffsetTZ == peer.mDstOffsetTZ));
}
- inline DataItemId getId() {
- return TAC_DATA_ITEM_ID;
+};
+
+class SystemStatusTimeChange : public SystemStatusItemBase,
+ public TimeChangeDataItemBase
+{
+public:
+ inline SystemStatusTimeChange(
+ int64_t currTimeMillis=0ULL, int32_t rawOffset=0, int32_t dstOffset=0) :
+ TimeChangeDataItemBase(currTimeMillis, rawOffset, dstOffset) {}
+ inline SystemStatusTimeChange(const TimeChangeDataItemBase& itemBase) :
+ TimeChangeDataItemBase(itemBase) {}
+ inline bool equals(const SystemStatusTimeChange& peer) {
+ return ((mCurrTimeMillis == peer.mCurrTimeMillis) &&
+ (mRawOffsetTZ == peer.mRawOffsetTZ) &&
+ (mDstOffsetTZ == peer.mDstOffsetTZ));
}
- inline void stringify(string& /*valueStr*/) { }
- inline int32_t copy(IDataItemCore* src, bool* dataItemCopied = nullptr) {
- SystemStatusTac* tac = static_cast<SystemStatusTac*>(src);
- mValue = tac->mValue;
- if (dataItemCopied) {
- *dataItemCopied = true;
+};
+
+class SystemStatusWifiSupplicantStatus : public SystemStatusItemBase,
+ public WifiSupplicantStatusDataItemBase
+{
+public:
+ inline SystemStatusWifiSupplicantStatus() :
+ WifiSupplicantStatusDataItemBase() {}
+ inline SystemStatusWifiSupplicantStatus(const WifiSupplicantStatusDataItemBase& itemBase) :
+ WifiSupplicantStatusDataItemBase(itemBase) {}
+ inline bool equals(const SystemStatusWifiSupplicantStatus& peer) {
+ return ((mState == peer.mState) &&
+ (mApMacAddressValid == peer.mApMacAddressValid) &&
+ (mWifiApSsidValid == peer.mWifiApSsidValid) &&
+ (mWifiApSsid == peer.mWifiApSsid));
}
- return 1;
- }
};
-class SystemStatusMccMnc : public SystemStatusItemBase, public IDataItemCore
+class SystemStatusShutdownState : public SystemStatusItemBase,
+ public ShutdownStateDataItemBase
{
public:
- inline SystemStatusMccMnc() :
- mValue("") {}
- inline SystemStatusMccMnc(std::string value) :
- mValue(value) {}
+ inline SystemStatusShutdownState(bool state=false) :
+ ShutdownStateDataItemBase(state) {}
+ inline SystemStatusShutdownState(const ShutdownStateDataItemBase& itemBase) :
+ ShutdownStateDataItemBase(itemBase) {}
+ inline bool equals(const SystemStatusShutdownState& peer) {
+ return (mState == peer.mState);
+ }
+};
- std::string mValue;
+class SystemStatusTac : public SystemStatusItemBase,
+ public TacDataItemBase
+{
+public:
+ inline SystemStatusTac(std::string value="") :
+ TacDataItemBase(value) {}
+ inline SystemStatusTac(const TacDataItemBase& itemBase) :
+ TacDataItemBase(itemBase) {}
+ inline bool equals(const SystemStatusTac& peer) {
+ return (mValue == peer.mValue);
+ }
+ inline void dump(void) {
+ LOC_LOGD("Tac: value=%s", mValue.c_str());
+ }
+};
- inline bool equals(SystemStatusMccMnc& peer) {
+class SystemStatusMccMnc : public SystemStatusItemBase,
+ public MccmncDataItemBase
+{
+public:
+ inline SystemStatusMccMnc(std::string value="") :
+ MccmncDataItemBase(value) {}
+ inline SystemStatusMccMnc(const MccmncDataItemBase& itemBase) :
+ MccmncDataItemBase(itemBase) {}
+ inline bool equals(const SystemStatusMccMnc& peer) {
return (mValue == peer.mValue);
}
inline void dump(void) {
LOC_LOGD("TacMccMnc value=%s", mValue.c_str());
}
- inline DataItemId getId() {
- return MCCMNC_DATA_ITEM_ID;
+};
+
+class SystemStatusBtDeviceScanDetail : public SystemStatusItemBase,
+ public BtDeviceScanDetailsDataItemBase
+{
+public:
+ inline SystemStatusBtDeviceScanDetail() :
+ BtDeviceScanDetailsDataItemBase() {}
+ inline SystemStatusBtDeviceScanDetail(const BtDeviceScanDetailsDataItemBase& itemBase) :
+ BtDeviceScanDetailsDataItemBase(itemBase) {}
+ inline bool equals(const SystemStatusBtDeviceScanDetail& /*peer*/) {
+ return true;
}
- inline void stringify(string& /*valueStr*/) { }
- inline int32_t copy(IDataItemCore* src, bool* dataItemCopied = nullptr) {
- SystemStatusMccMnc* mccmnc = static_cast<SystemStatusMccMnc*>(src);
- mValue = mccmnc->mValue;
- if (dataItemCopied) {
- *dataItemCopied = true;
- }
- return 1;
+};
+
+class SystemStatusBtleDeviceScanDetail : public SystemStatusItemBase,
+ public BtLeDeviceScanDetailsDataItemBase
+{
+public:
+ inline SystemStatusBtleDeviceScanDetail() :
+ BtLeDeviceScanDetailsDataItemBase() {}
+ inline SystemStatusBtleDeviceScanDetail(const BtLeDeviceScanDetailsDataItemBase& itemBase) :
+ BtLeDeviceScanDetailsDataItemBase(itemBase) {}
+ inline bool equals(const SystemStatusBtleDeviceScanDetail& /*peer*/) {
+ return true;
}
};
@@ -557,10 +730,28 @@ public:
std::vector<SystemStatusPositionFailure> mPositionFailure;
// from dataitems observer
- std::vector<SystemStatusGpsState> mGpsState;
+ std::vector<SystemStatusAirplaneMode> mAirplaneMode;
+ std::vector<SystemStatusENH> mENH;
+ std::vector<SystemStatusGpsState> mGPSState;
+ std::vector<SystemStatusNLPStatus> mNLPStatus;
+ std::vector<SystemStatusWifiHardwareState> mWifiHardwareState;
std::vector<SystemStatusNetworkInfo> mNetworkInfo;
+ std::vector<SystemStatusServiceInfo> mRilServiceInfo;
+ std::vector<SystemStatusRilCellInfo> mRilCellInfo;
+ std::vector<SystemStatusServiceStatus> mServiceStatus;
+ std::vector<SystemStatusModel> mModel;
+ std::vector<SystemStatusManufacturer> mManufacturer;
+ std::vector<SystemStatusAssistedGps> mAssistedGps;
+ std::vector<SystemStatusScreenState> mScreenState;
+ std::vector<SystemStatusPowerConnectState> mPowerConnectState;
+ std::vector<SystemStatusTimeZoneChange> mTimeZoneChange;
+ std::vector<SystemStatusTimeChange> mTimeChange;
+ std::vector<SystemStatusWifiSupplicantStatus> mWifiSupplicantStatus;
+ std::vector<SystemStatusShutdownState> mShutdownState;
std::vector<SystemStatusTac> mTac;
std::vector<SystemStatusMccMnc> mMccMnc;
+ std::vector<SystemStatusBtDeviceScanDetail> mBtDeviceScanDetail;
+ std::vector<SystemStatusBtleDeviceScanDetail> mBtLeDeviceScanDetail;
};
/******************************************************************************
@@ -578,50 +769,21 @@ private:
// Data members
static pthread_mutex_t mMutexSystemStatus;
-
- static const uint32_t maxLocation = 5;
-
- static const uint32_t maxTimeAndClock = 5;
- static const uint32_t maxXoState = 5;
- static const uint32_t maxRfAndParams = 5;
- static const uint32_t maxErrRecovery = 5;
-
- static const uint32_t maxInjectedPosition = 5;
- static const uint32_t maxBestPosition = 5;
- static const uint32_t maxXtra = 5;
- static const uint32_t maxEphemeris = 5;
- static const uint32_t maxSvHealth = 5;
- static const uint32_t maxPdr = 5;
- static const uint32_t maxNavData = 5;
-
- static const uint32_t maxPositionFailure = 5;
-
- static const uint32_t maxGpsState = 5;
- static const uint32_t maxNetworkInfo = 5;
- static const uint32_t maxTac = 5;
- static const uint32_t maxMccMnc = 5;
-
SystemStatusReports mCache;
bool mConnected;
- bool setLocation(const UlpLocation& location);
-
- bool setTimeAndCLock(const SystemStatusPQWM1& nmea);
- bool setXoState(const SystemStatusPQWM1& nmea);
- bool setRfAndParams(const SystemStatusPQWM1& nmea);
- bool setErrRecovery(const SystemStatusPQWM1& nmea);
+ template <typename TYPE_SYSTEMSTATUS_ITEM, typename TYPE_REPORT, typename TYPE_ITEMBASE>
+ bool setItemBaseinReport(TYPE_REPORT& report, const TYPE_ITEMBASE& s);
- bool setInjectedPosition(const SystemStatusPQWP1& nmea);
- bool setBestPosition(const SystemStatusPQWP2& nmea);
- bool setXtra(const SystemStatusPQWP3& nmea);
- bool setEphemeris(const SystemStatusPQWP4& nmea);
- bool setSvHealth(const SystemStatusPQWP5& nmea);
- bool setPdr(const SystemStatusPQWP6& nmea);
- bool setNavData(const SystemStatusPQWP7& nmea);
+ template <typename TYPE_REPORT, typename TYPE_ITEM>
+ bool setIteminReport(TYPE_REPORT& report, const TYPE_ITEM& s);
- bool setPositionFailure(const SystemStatusPQWS1& nmea);
+ // set default dataitem derived item in report cache
+ template <typename TYPE_REPORT, typename TYPE_ITEM>
+ void setDefaultIteminReport(TYPE_REPORT& report, const TYPE_ITEM& s);
- bool setNetworkInfo(IDataItemCore* dataitem);
+ template <typename TYPE_REPORT, typename TYPE_ITEM>
+ void getIteminReport(TYPE_REPORT& reportout, const TYPE_ITEM& c) const;
public:
// Static methods
diff --git a/gps/core/SystemStatusOsObserver.cpp b/gps/core/SystemStatusOsObserver.cpp
index 319f1d7..541b5fd 100644
--- a/gps/core/SystemStatusOsObserver.cpp
+++ b/gps/core/SystemStatusOsObserver.cpp
@@ -39,7 +39,9 @@
namespace loc_core
{
-SystemStatusOsObserver::SystemStatusOsObserver(const MsgTask* msgTask) :
+SystemStatusOsObserver::SystemStatusOsObserver(
+ SystemStatus* systemstatus, const MsgTask* msgTask) :
+ mSystemStatus(systemstatus),
mAddress("SystemStatusOsObserver"),
mClientIndex(IndexFactory<IDataItemObserver*, DataItemId> :: createClientIndex()),
mDataItemIndex(IndexFactory<IDataItemObserver*, DataItemId> :: createDataItemIndex())
@@ -366,11 +368,11 @@ void SystemStatusOsObserver::notify(const list<IDataItemCore*>& dlist)
// Copy contents into the newly created data item
di->copy(each);
- dataItemList.push_back(di);
+
// Request systemstatus to record this dataitem in its cache
- SystemStatus* systemstatus = SystemStatus::getInstance(mContext.mMsgTask);
- if(nullptr != systemstatus) {
- systemstatus->eventDataItemNotify(di);
+ if (mSystemStatus->eventDataItemNotify(di)) {
+ // add this dataitem if updated from last one
+ dataItemList.push_back(di);
}
}
diff --git a/gps/core/SystemStatusOsObserver.h b/gps/core/SystemStatusOsObserver.h
index 985e5c9..fa114ee 100644
--- a/gps/core/SystemStatusOsObserver.h
+++ b/gps/core/SystemStatusOsObserver.h
@@ -70,12 +70,13 @@ typedef map<IDataItemObserver*, list<DataItemId>> ObserverReqCache;
// subscribe with OSObserver using IDataItemSubscription interface.
// Such clients would need to implement IDataItemObserver interface
// to receive data when it becomes available.
+class SystemStatus;
class SystemStatusOsObserver : public IOsObserver {
public:
// ctor
- SystemStatusOsObserver(const MsgTask* msgTask);
-
+ SystemStatusOsObserver(
+ SystemStatus* systemstatus, const MsgTask* msgTask);
// dtor
~SystemStatusOsObserver();
@@ -105,6 +106,7 @@ public:
virtual void turnOff(DataItemId dit);
private:
+ SystemStatus* mSystemStatus;
SystemContext mContext;
const string mAddress;
IClientIndex<IDataItemObserver*, DataItemId>* mClientIndex;
diff --git a/gps/core/data-items/DataItemConcreteTypesBase.h b/gps/core/data-items/DataItemConcreteTypesBase.h
new file mode 100644
index 0000000..df3bf9a
--- /dev/null
+++ b/gps/core/data-items/DataItemConcreteTypesBase.h
@@ -0,0 +1,461 @@
+/* Copyright (c) 2015-2017, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution.
+ * * Neither the name of The Linux Foundation, nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef __DATAITEMCONCRETEBASETYPES__
+#define __DATAITEMCONCRETEBASETYPES__
+
+#include <string>
+#include <cstring>
+#include <DataItemId.h>
+#include <IDataItemCore.h>
+
+#define MAC_ADDRESS_LENGTH 6
+// MAC address length in bytes
+// QMI_LOC_SRN_MAC_ADDR_LENGTH_V02
+#define SRN_MAC_ADDRESS_LENGTH 6
+#define WIFI_SUPPLICANT_DEFAULT_STATE 0
+
+namespace loc_core
+{
+using namespace std;
+
+class AirplaneModeDataItemBase : public IDataItemCore {
+public:
+ AirplaneModeDataItemBase(bool mode):
+ mMode(mode),
+ mId(AIRPLANEMODE_DATA_ITEM_ID) {}
+ virtual ~AirplaneModeDataItemBase() {}
+ inline virtual DataItemId getId() { return mId; }
+ virtual void stringify(string& /*valueStr*/) {}
+ virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;}
+// Data members
+ bool mMode;
+
+protected:
+ DataItemId mId;
+};
+
+class ENHDataItemBase : public IDataItemCore {
+public:
+ ENHDataItemBase(bool enabled) :
+ mEnabled(enabled),
+ mId(ENH_DATA_ITEM_ID) {}
+ virtual ~ENHDataItemBase() {}
+ inline virtual DataItemId getId() { return mId; }
+ virtual void stringify(string& /*valueStr*/) {}
+ virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;}
+// Data members
+ bool mEnabled;
+protected:
+ DataItemId mId;
+};
+
+class GPSStateDataItemBase : public IDataItemCore {
+public:
+ GPSStateDataItemBase(bool enabled) :
+ mEnabled(enabled),
+ mId(GPSSTATE_DATA_ITEM_ID) {}
+ virtual ~GPSStateDataItemBase() {}
+ inline virtual DataItemId getId() { return mId; }
+ virtual void stringify(string& /*valueStr*/) {}
+ virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;}
+// Data members
+ bool mEnabled;
+protected:
+ DataItemId mId;
+};
+
+class NLPStatusDataItemBase : public IDataItemCore {
+public:
+ NLPStatusDataItemBase(bool enabled) :
+ mEnabled(enabled),
+ mId(NLPSTATUS_DATA_ITEM_ID) {}
+ virtual ~NLPStatusDataItemBase() {}
+ inline virtual DataItemId getId() { return mId; }
+ virtual void stringify(string& /*valueStr*/) {}
+ virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;}
+// Data members
+ bool mEnabled;
+protected:
+ DataItemId mId;
+};
+
+class WifiHardwareStateDataItemBase : public IDataItemCore {
+public:
+ WifiHardwareStateDataItemBase(bool enabled) :
+ mEnabled(enabled),
+ mId(WIFIHARDWARESTATE_DATA_ITEM_ID) {}
+ virtual ~WifiHardwareStateDataItemBase() {}
+ inline virtual DataItemId getId() { return mId; }
+ virtual void stringify(string& /*valueStr*/) {}
+ virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;}
+// Data members
+ bool mEnabled;
+protected:
+ DataItemId mId;
+};
+
+class ScreenStateDataItemBase : public IDataItemCore {
+public:
+ ScreenStateDataItemBase(bool state) :
+ mState(state),
+ mId(SCREEN_STATE_DATA_ITEM_ID) {}
+ virtual ~ScreenStateDataItemBase() {}
+ inline virtual DataItemId getId() { return mId; }
+ virtual void stringify(string& /*valueStr*/) {}
+ virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;}
+// Data members
+ bool mState;
+protected:
+ DataItemId mId;
+};
+
+class PowerConnectStateDataItemBase : public IDataItemCore {
+public:
+ PowerConnectStateDataItemBase(bool state) :
+ mState(state),
+ mId(POWER_CONNECTED_STATE_DATA_ITEM_ID) {}
+ virtual ~PowerConnectStateDataItemBase() {}
+ inline virtual DataItemId getId() { return mId; }
+ virtual void stringify(string& /*valueStr*/) {}
+ virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;}
+// Data members
+ bool mState;
+protected:
+ DataItemId mId;
+};
+
+class TimeZoneChangeDataItemBase : public IDataItemCore {
+public:
+ TimeZoneChangeDataItemBase(int64_t currTimeMillis, int32_t rawOffset, int32_t dstOffset) :
+ mCurrTimeMillis (currTimeMillis),
+ mRawOffsetTZ (rawOffset),
+ mDstOffsetTZ (dstOffset),
+ mId(TIMEZONE_CHANGE_DATA_ITEM_ID) {}
+ virtual ~TimeZoneChangeDataItemBase() {}
+ inline virtual DataItemId getId() { return mId; }
+ virtual void stringify(string& /*valueStr*/) {}
+ virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;}
+// Data members
+ int64_t mCurrTimeMillis;
+ int32_t mRawOffsetTZ;
+ int32_t mDstOffsetTZ;
+protected:
+ DataItemId mId;
+};
+
+class TimeChangeDataItemBase : public IDataItemCore {
+public:
+ TimeChangeDataItemBase(int64_t currTimeMillis, int32_t rawOffset, int32_t dstOffset) :
+ mCurrTimeMillis (currTimeMillis),
+ mRawOffsetTZ (rawOffset),
+ mDstOffsetTZ (dstOffset),
+ mId(TIME_CHANGE_DATA_ITEM_ID) {}
+ virtual ~TimeChangeDataItemBase() {}
+ inline virtual DataItemId getId() { return mId; }
+ virtual void stringify(string& /*valueStr*/) {}
+ virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;}
+// Data members
+ int64_t mCurrTimeMillis;
+ int32_t mRawOffsetTZ;
+ int32_t mDstOffsetTZ;
+protected:
+ DataItemId mId;
+};
+
+class ShutdownStateDataItemBase : public IDataItemCore {
+public:
+ ShutdownStateDataItemBase(bool state) :
+ mState (state),
+ mId(SHUTDOWN_STATE_DATA_ITEM_ID) {}
+ virtual ~ShutdownStateDataItemBase() {}
+ inline virtual DataItemId getId() { return mId; }
+ virtual void stringify(string& /*valueStr*/) {}
+ virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;}
+// Data members
+ bool mState;
+protected:
+ DataItemId mId;
+};
+
+class AssistedGpsDataItemBase : public IDataItemCore {
+public:
+ AssistedGpsDataItemBase(bool enabled) :
+ mEnabled(enabled),
+ mId(ASSISTED_GPS_DATA_ITEM_ID) {}
+ virtual ~AssistedGpsDataItemBase() {}
+ inline virtual DataItemId getId() { return mId; }
+ virtual void stringify(string& /*valueStr*/) {}
+ virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;}
+// Data members
+ bool mEnabled;
+protected:
+ DataItemId mId;
+};
+
+class NetworkInfoDataItemBase : public IDataItemCore {
+public:
+ NetworkInfoDataItemBase(
+ int32_t type, string typeName, string subTypeName,
+ bool available, bool connected, bool roaming ):
+ mType(type),
+ mTypeName(typeName),
+ mSubTypeName(subTypeName),
+ mAvailable(available),
+ mConnected(connected),
+ mRoaming(roaming),
+ mId(NETWORKINFO_DATA_ITEM_ID) {}
+ virtual ~NetworkInfoDataItemBase() {}
+ inline virtual DataItemId getId() { return mId; }
+ virtual void stringify(string& /*valueStr*/) {}
+ virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;}
+ enum NetworkType {
+ TYPE_UNKNOWN,
+ TYPE_MOBILE,
+ TYPE_WIFI,
+ TYPE_ETHERNET,
+ TYPE_BLUETOOTH,
+ TYPE_MMS,
+ TYPE_SUPL,
+ TYPE_DUN,
+ TYPE_HIPRI,
+ TYPE_WIMAX
+ };
+ inline virtual NetworkType getType(void) const {
+ return (NetworkType)mType;
+ }
+// Data members
+ int32_t mType;
+ string mTypeName;
+ string mSubTypeName;
+ bool mAvailable;
+ bool mConnected;
+ bool mRoaming;
+protected:
+ DataItemId mId;
+
+};
+
+class ServiceStatusDataItemBase : public IDataItemCore {
+public:
+ ServiceStatusDataItemBase(int32_t serviceState) :
+ mServiceState (serviceState),
+ mId(SERVICESTATUS_DATA_ITEM_ID) {}
+ virtual ~ServiceStatusDataItemBase() {}
+ inline virtual DataItemId getId() { return mId; }
+ virtual void stringify(string& /*valueStr*/) {}
+ virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;}
+// Data members
+ int32_t mServiceState;
+protected:
+ DataItemId mId;
+};
+
+class ModelDataItemBase : public IDataItemCore {
+public:
+ ModelDataItemBase(const string & name) :
+ mModel (name),
+ mId(MODEL_DATA_ITEM_ID) {}
+ virtual ~ModelDataItemBase() {}
+ inline virtual DataItemId getId() { return mId; }
+ virtual void stringify(string& /*valueStr*/) {}
+ virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;}
+// Data members
+ string mModel;
+protected:
+ DataItemId mId;
+};
+
+class ManufacturerDataItemBase : public IDataItemCore {
+public:
+ ManufacturerDataItemBase(const string & name) :
+ mManufacturer (name),
+ mId(MANUFACTURER_DATA_ITEM_ID) {}
+ virtual ~ManufacturerDataItemBase() {}
+ inline virtual DataItemId getId() { return mId; }
+ virtual void stringify(string& /*valueStr*/) {}
+ virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;}
+// Data members
+ string mManufacturer;
+protected:
+ DataItemId mId;
+};
+
+class RilServiceInfoDataItemBase : public IDataItemCore {
+public:
+ RilServiceInfoDataItemBase() :
+ mId(RILSERVICEINFO_DATA_ITEM_ID) {}
+ virtual ~RilServiceInfoDataItemBase() {}
+ inline virtual DataItemId getId() { return mId; }
+ virtual void stringify(string& /*valueStr*/) {}
+ virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;}
+protected:
+ DataItemId mId;
+};
+
+class RilCellInfoDataItemBase : public IDataItemCore {
+public:
+ RilCellInfoDataItemBase() :
+ mId(RILCELLINFO_DATA_ITEM_ID) {}
+ virtual ~RilCellInfoDataItemBase() {}
+ inline virtual DataItemId getId() { return mId; }
+ virtual void stringify(string& /*valueStr*/) {}
+ virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;}
+protected:
+ DataItemId mId;
+};
+
+class WifiSupplicantStatusDataItemBase : public IDataItemCore {
+public:
+ WifiSupplicantStatusDataItemBase() :
+ mState((WifiSupplicantState)WIFI_SUPPLICANT_DEFAULT_STATE),
+ mApMacAddressValid(false),
+ mWifiApSsidValid(false),
+ mId(WIFI_SUPPLICANT_STATUS_DATA_ITEM_ID) {
+ memset (&mApMacAddress, 0, sizeof (mApMacAddress));
+ mWifiApSsid.clear();
+ }
+ virtual ~WifiSupplicantStatusDataItemBase() {}
+ inline virtual DataItemId getId() { return mId; }
+ virtual void stringify(string& /*valueStr*/) {}
+ virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;}
+ // Data members
+ typedef enum WifiSupplicantState {
+ DISCONNECTED,
+ INTERFACE_DISABLED,
+ INACTIVE,
+ SCANNING,
+ AUTHENTICATING,
+ ASSOCIATING,
+ ASSOCIATED,
+ FOUR_WAY_HANDSHAKE,
+ GROUP_HANDSHAKE,
+ COMPLETED,
+ DORMANT,
+ UNINITIALIZED,
+ INVALID
+ } WifiSupplicantState;
+ /* Represents whether access point attach state*/
+ WifiSupplicantState mState;
+ /* Represents info on whether ap mac address is valid */
+ bool mApMacAddressValid;
+ /* Represents mac address of the wifi access point*/
+ uint8_t mApMacAddress[MAC_ADDRESS_LENGTH];
+ /* Represents info on whether ap SSID is valid */
+ bool mWifiApSsidValid;
+ /* Represents Wifi SSID string*/
+ string mWifiApSsid;
+protected:
+ DataItemId mId;
+};
+
+class TacDataItemBase : public IDataItemCore {
+public:
+ TacDataItemBase(const string & name) :
+ mValue (name),
+ mId(TAC_DATA_ITEM_ID) {}
+ virtual ~TacDataItemBase() {}
+ inline virtual DataItemId getId() { return mId; }
+ virtual void stringify(string& /*valueStr*/) {}
+ virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;}
+// Data members
+ string mValue;
+protected:
+ DataItemId mId;
+};
+
+class MccmncDataItemBase : public IDataItemCore {
+public:
+ MccmncDataItemBase(const string & name) :
+ mValue (name),
+ mId(MCCMNC_DATA_ITEM_ID) {}
+ virtual ~MccmncDataItemBase() {}
+ inline virtual DataItemId getId() { return mId; }
+ virtual void stringify(string& /*valueStr*/) {}
+ virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;}
+// Data members
+ string mValue;
+protected:
+ DataItemId mId;
+};
+
+class SrnDeviceScanDetailsDataItemBase : public IDataItemCore {
+public:
+ SrnDeviceScanDetailsDataItemBase (DataItemId Id) :
+ mValidSrnData(false),
+ mApSrnRssi(-1),
+ mApSrnTimestamp(0),
+ mRequestTimestamp(0),
+ mReceiveTimestamp(0),
+ mErrorCause(-1),
+ mId(Id) {}
+ virtual ~SrnDeviceScanDetailsDataItemBase () {}
+ inline virtual DataItemId getId() { return mId; }
+ // Data members common to all SRN tech types
+ /* Represents info on whether SRN data is valid (no error)*/
+ bool mValidSrnData;
+ /* SRN device RSSI reported */
+ int32_t mApSrnRssi;
+ /* MAC adress of SRN device */
+ uint8_t mApSrnMacAddress[SRN_MAC_ADDRESS_LENGTH];
+ /* UTC timestamp at which the scan was requested.for this SRN device*/
+ int64_t mApSrnTimestamp;
+ /* UTC timestamp at which the scan was started. */
+ int64_t mRequestTimestamp;
+ /* UTC timestamp at which the scan was received.*/
+ int64_t mReceiveTimestamp;
+ /* Reason for the error/failure if SRN details are not valid */
+ int32_t mErrorCause;
+protected:
+ DataItemId mId;
+};
+
+class BtDeviceScanDetailsDataItemBase : public SrnDeviceScanDetailsDataItemBase {
+
+public:
+ BtDeviceScanDetailsDataItemBase() :
+ SrnDeviceScanDetailsDataItemBase(BT_SCAN_DATA_ITEM_ID) {}
+ virtual ~BtDeviceScanDetailsDataItemBase() {}
+ virtual void stringify(string& /*valueStr*/) {}
+ virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;}
+};
+
+class BtLeDeviceScanDetailsDataItemBase : public SrnDeviceScanDetailsDataItemBase {
+
+public:
+ BtLeDeviceScanDetailsDataItemBase() :
+ SrnDeviceScanDetailsDataItemBase(BTLE_SCAN_DATA_ITEM_ID) {}
+ virtual ~BtLeDeviceScanDetailsDataItemBase() {}
+ virtual void stringify(string& /*valueStr*/) {}
+ virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;}
+};
+
+} // namespace loc_core
+
+#endif //__DATAITEMCONCRETEBASETYPES__
diff --git a/gps/gnss/XtraSystemStatusObserver.cpp b/gps/gnss/XtraSystemStatusObserver.cpp
index ce08f64..2855c0d 100644
--- a/gps/gnss/XtraSystemStatusObserver.cpp
+++ b/gps/gnss/XtraSystemStatusObserver.cpp
@@ -47,6 +47,7 @@
#include <LocAdapterBase.h>
#include <DataItemId.h>
#include <DataItemsFactoryProxy.h>
+#include <DataItemConcreteTypesBase.h>
using namespace loc_core;
@@ -201,8 +202,8 @@ void XtraSystemStatusObserver::notify(const list<IDataItemCore*>& dlist)
{
case NETWORKINFO_DATA_ITEM_ID:
{
- SystemStatusNetworkInfo* networkInfo =
- reinterpret_cast<SystemStatusNetworkInfo*>(each);
+ NetworkInfoDataItemBase* networkInfo =
+ static_cast<NetworkInfoDataItemBase*>(each);
mXtraSysStatObj->updateConnectionStatus(networkInfo->mConnected,
networkInfo->mType);
}
@@ -210,14 +211,16 @@ void XtraSystemStatusObserver::notify(const list<IDataItemCore*>& dlist)
case TAC_DATA_ITEM_ID:
{
- SystemStatusTac* tac = reinterpret_cast<SystemStatusTac*>(each);
+ TacDataItemBase* tac =
+ static_cast<TacDataItemBase*>(each);
mXtraSysStatObj->updateTac(tac->mValue);
}
break;
case MCCMNC_DATA_ITEM_ID:
{
- SystemStatusMccMnc* mccmnc = reinterpret_cast<SystemStatusMccMnc*>(each);
+ MccmncDataItemBase* mccmnc =
+ static_cast<MccmncDataItemBase*>(each);
mXtraSysStatObj->updateMccMnc(mccmnc->mValue);
}
break;
diff --git a/gps/location/LocationAPI.h b/gps/location/LocationAPI.h
index f5cc75a..530b1b0 100644
--- a/gps/location/LocationAPI.h
+++ b/gps/location/LocationAPI.h
@@ -308,8 +308,9 @@ typedef enum {
} GnssSuplMode;
typedef enum {
- BATCHING_MODE_ROUTINE = 0,
- BATCHING_MODE_TRIP
+ BATCHING_MODE_ROUTINE = 0, // positions are reported when batched positions memory is full
+ BATCHING_MODE_TRIP, // positions are reported when a certain distance is covered
+ BATCHING_MODE_NO_AUTO_REPORT // no report of positions automatically, instead queried on demand
} BatchingMode;
typedef enum {
diff --git a/gps/location/LocationAPIClientBase.cpp b/gps/location/LocationAPIClientBase.cpp
index 070c585..50b4b83 100644
--- a/gps/location/LocationAPIClientBase.cpp
+++ b/gps/location/LocationAPIClientBase.cpp
@@ -393,14 +393,20 @@ uint32_t LocationAPIClientBase::locAPIStartSession(uint32_t id, uint32_t session
trackingSession = mLocationAPI->startTracking(locationOptions);
LOC_LOGI("%s:%d] start new session: %d", __FUNCTION__, __LINE__, trackingSession);
mRequestQueues[REQUEST_SESSION].push(new StartTrackingRequest(*this));
- } else if ((sessionMode == SESSION_MODE_ON_FULL) ||
- (sessionMode == SESSION_MODE_ON_TRIP_COMPLETED)) {
+ } else {
// Fill in the batch mode
BatchingOptions batchOptions = {};
batchOptions.size = sizeof(BatchingOptions);
- batchOptions.batchingMode = BATCHING_MODE_ROUTINE;
- if (sessionMode == SESSION_MODE_ON_TRIP_COMPLETED) {
+ switch (sessionMode) {
+ case SESSION_MODE_ON_FULL:
+ batchOptions.batchingMode = BATCHING_MODE_ROUTINE;
+ break;
+ case SESSION_MODE_ON_TRIP_COMPLETED:
batchOptions.batchingMode = BATCHING_MODE_TRIP;
+ break;
+ default:
+ batchOptions.batchingMode = BATCHING_MODE_NO_AUTO_REPORT;
+ break;
}
batchingSession = mLocationAPI->startBatching(locationOptions, batchOptions);
@@ -409,8 +415,7 @@ uint32_t LocationAPIClientBase::locAPIStartSession(uint32_t id, uint32_t session
mRequestQueues[REQUEST_SESSION].push(new StartBatchingRequest(*this));
}
- uint32_t session = ((sessionMode == SESSION_MODE_ON_FULL ||
- (sessionMode == SESSION_MODE_ON_TRIP_COMPLETED)) ?
+ uint32_t session = ((sessionMode != SESSION_MODE_ON_FIX) ?
batchingSession : trackingSession);
SessionEntity entity;
@@ -445,12 +450,9 @@ uint32_t LocationAPIClientBase::locAPIStopSession(uint32_t id)
if (sMode == SESSION_MODE_ON_FIX) {
mRequestQueues[REQUEST_SESSION].push(new StopTrackingRequest(*this));
mLocationAPI->stopTracking(trackingSession);
- } else if ((sMode == SESSION_MODE_ON_FULL) ||
- (sMode == SESSION_MODE_ON_TRIP_COMPLETED)) {
+ } else {
mRequestQueues[REQUEST_SESSION].push(new StopBatchingRequest(*this));
mLocationAPI->stopBatching(batchingSession);
- } else {
- LOC_LOGE("%s:%d] unknown mode %d.", __FUNCTION__, __LINE__, sMode);
}
retVal = LOCATION_ERROR_SUCCESS;
@@ -484,8 +486,7 @@ uint32_t LocationAPIClientBase::locAPIUpdateSessionOptions(uint32_t id, uint32_t
mRequestQueues[REQUEST_SESSION].push(new UpdateTrackingOptionsRequest(*this));
if (sMode == SESSION_MODE_ON_FIX) {
mLocationAPI->updateTrackingOptions(trackingSession, options);
- } else if ((sMode == SESSION_MODE_ON_FULL) ||
- (sMode == SESSION_MODE_ON_TRIP_COMPLETED)) {
+ } else {
// stop batching
// batchingSession will be removed from mSessionBiDict soon,
// so we don't need to add a new request to mRequestQueues[REQUEST_SESSION].
@@ -497,19 +498,23 @@ uint32_t LocationAPIClientBase::locAPIUpdateSessionOptions(uint32_t id, uint32_t
trackingSession = mLocationAPI->startTracking(options);
LOC_LOGI("%s:%d] start new session: %d",
__FUNCTION__, __LINE__, trackingSession);
- } else {
- LOC_LOGE("%s:%d] unknown mode %d", __FUNCTION__, __LINE__, sMode);
}
- } else if ((sessionMode == SESSION_MODE_ON_FULL) ||
- (sessionMode == SESSION_MODE_ON_TRIP_COMPLETED)) {
+ } else {
// we only add an UpdateBatchingOptionsRequest to mRequestQueues[REQUEST_SESSION],
// even if this update request will stop tracking and then start batching.
mRequestQueues[REQUEST_SESSION].push(new UpdateBatchingOptionsRequest(*this));
BatchingOptions batchOptions = {};
batchOptions.size = sizeof(BatchingOptions);
- batchOptions.batchingMode = BATCHING_MODE_ROUTINE;
- if (sessionMode == SESSION_MODE_ON_TRIP_COMPLETED) {
- batchOptions.batchingMode = BATCHING_MODE_TRIP;
+ switch (sessionMode) {
+ case SESSION_MODE_ON_FULL:
+ batchOptions.batchingMode = BATCHING_MODE_ROUTINE;
+ break;
+ case SESSION_MODE_ON_TRIP_COMPLETED:
+ batchOptions.batchingMode = BATCHING_MODE_TRIP;
+ break;
+ default:
+ batchOptions.batchingMode = BATCHING_MODE_NO_AUTO_REPORT;
+ break;
}
if (sMode == SESSION_MODE_ON_FIX) {
@@ -524,19 +529,13 @@ uint32_t LocationAPIClientBase::locAPIUpdateSessionOptions(uint32_t id, uint32_t
LOC_LOGI("%s:%d] start new session: %d",
__FUNCTION__, __LINE__, batchingSession);
mRequestQueues[REQUEST_SESSION].setSession(batchingSession);
- } else if ((sMode == SESSION_MODE_ON_FULL) ||
- (sMode == SESSION_MODE_ON_TRIP_COMPLETED)) {
- mLocationAPI->updateBatchingOptions(batchingSession, options, batchOptions);
} else {
- LOC_LOGE("%s:%d] unknown mode %d", __FUNCTION__, __LINE__, sMode);
+ mLocationAPI->updateBatchingOptions(batchingSession, options, batchOptions);
}
- } else {
- LOC_LOGE("%s:%d] unknown mode %d.", __FUNCTION__, __LINE__, sessionMode);
}
- uint32_t session = ((sessionMode == SESSION_MODE_ON_FULL) ||
- (sessionMode == SESSION_MODE_ON_TRIP_COMPLETED) ?
+ uint32_t session = ((sessionMode != SESSION_MODE_ON_FIX) ?
batchingSession : trackingSession);
entity.trackingSession = trackingSession;
@@ -556,22 +555,25 @@ uint32_t LocationAPIClientBase::locAPIUpdateSessionOptions(uint32_t id, uint32_t
return retVal;
}
-void LocationAPIClientBase::locAPIGetBatchedLocations(uint32_t id, size_t count)
+uint32_t LocationAPIClientBase::locAPIGetBatchedLocations(uint32_t id, size_t count)
{
+ uint32_t retVal = LOCATION_ERROR_GENERAL_FAILURE;
pthread_mutex_lock(&mMutex);
if (mLocationAPI) {
- uint32_t session = 0;
- session = mRequestQueues[REQUEST_SESSION].getSession();
- if (session > 0) {
+ if (mSessionBiDict.hasId(id)) {
SessionEntity entity = mSessionBiDict.getExtById(id);
uint32_t batchingSession = entity.batchingSession;
mRequestQueues[REQUEST_SESSION].push(new GetBatchedLocationsRequest(*this));
mLocationAPI->getBatchedLocations(batchingSession, count);
+ retVal = LOCATION_ERROR_SUCCESS;
} else {
- LOC_LOGE("%s:%d] invalid session: %d.", __FUNCTION__, __LINE__, session);
+ retVal = LOCATION_ERROR_ID_UNKNOWN;
+ LOC_LOGE("%s:%d] invalid session: %d.", __FUNCTION__, __LINE__, id);
}
}
pthread_mutex_unlock(&mMutex);
+
+ return retVal;
}
uint32_t LocationAPIClientBase::locAPIAddGeofences(
@@ -613,12 +615,22 @@ void LocationAPIClientBase::locAPIRemoveGeofences(size_t count, uint32_t* ids)
if (mRequestQueues[REQUEST_GEOFENCE].getSession() == GEOFENCE_SESSION_ID) {
size_t j = 0;
+ uint32_t id_cb;
+ LocationError err;
for (size_t i = 0; i < count; i++) {
sessions[j] = mGeofenceBiDict.getSession(ids[i]);
+ id_cb = ids[i];
if (sessions[j] > 0) {
+ mGeofenceBiDict.rmBySession(sessions[j]);
+ err = LOCATION_ERROR_SUCCESS;
+ onRemoveGeofencesCb(1, &err, &id_cb);
j++;
+ } else {
+ err = LOCATION_ERROR_ID_UNKNOWN;
+ onRemoveGeofencesCb(1, &err, &id_cb);
}
}
+
if (j > 0) {
mRequestQueues[REQUEST_GEOFENCE].push(new RemoveGeofencesRequest(*this));
mLocationAPI->removeGeofences(j, sessions);
@@ -743,38 +755,8 @@ void LocationAPIClientBase::locAPIResumeGeofences(
void LocationAPIClientBase::locAPIRemoveAllGeofences()
{
- pthread_mutex_lock(&mMutex);
- if (mLocationAPI) {
- std::vector<uint32_t> sessionsVec = mGeofenceBiDict.getAllSessions();
- size_t count = sessionsVec.size();
- uint32_t* sessions = (uint32_t*)malloc(sizeof(uint32_t) * count);
- if (sessions == NULL) {
- LOC_LOGE("%s:%d] Failed to allocate %zu bytes !",
- __FUNCTION__, __LINE__, sizeof(uint32_t) * count);
- pthread_mutex_unlock(&mMutex);
- return;
- }
-
- if (mRequestQueues[REQUEST_GEOFENCE].getSession() == GEOFENCE_SESSION_ID) {
- size_t j = 0;
- for (size_t i = 0; i < count; i++) {
- sessions[j] = sessionsVec[i];
- if (sessions[j] > 0) {
- j++;
- }
- }
- if (j > 0) {
- mRequestQueues[REQUEST_GEOFENCE].push(new RemoveGeofencesRequest(*this));
- mLocationAPI->removeGeofences(j, sessions);
- }
- } else {
- LOC_LOGE("%s:%d] invalid session: %d.", __FUNCTION__, __LINE__,
- mRequestQueues[REQUEST_GEOFENCE].getSession());
- }
-
- free(sessions);
- }
- pthread_mutex_unlock(&mMutex);
+ std::vector<uint32_t> sessionsVec = mGeofenceBiDict.getAllSessions();
+ locAPIRemoveGeofences(sessionsVec.size(), &sessionsVec[0]);
}
void LocationAPIClientBase::locAPIGnssNiResponse(uint32_t id, GnssNiResponse response)
diff --git a/gps/location/LocationAPIClientBase.h b/gps/location/LocationAPIClientBase.h
index a856054..c6ea05c 100644
--- a/gps/location/LocationAPIClientBase.h
+++ b/gps/location/LocationAPIClientBase.h
@@ -195,7 +195,7 @@ public:
uint32_t locAPIStopSession(uint32_t id);
uint32_t locAPIUpdateSessionOptions(uint32_t id, uint32_t sessionMode,
LocationOptions& options);
- void locAPIGetBatchedLocations(uint32_t id, size_t count);
+ uint32_t locAPIGetBatchedLocations(uint32_t id, size_t count);
uint32_t locAPIAddGeofences(size_t count, uint32_t* ids,
GeofenceOption* options, GeofenceInfo* data);
@@ -381,7 +381,10 @@ private:
class StartTrackingRequest : public LocationAPIRequest {
public:
StartTrackingRequest(LocationAPIClientBase& API) : mAPI(API) {}
- inline void onResponse(LocationError error, uint32_t /*id*/) {
+ inline void onResponse(LocationError error, uint32_t id) {
+ if (error != LOCATION_ERROR_SUCCESS) {
+ mAPI.removeSession(id);
+ }
mAPI.onStartTrackingCb(error);
}
LocationAPIClientBase& mAPI;
@@ -411,7 +414,10 @@ private:
class StartBatchingRequest : public LocationAPIRequest {
public:
StartBatchingRequest(LocationAPIClientBase& API) : mAPI(API) {}
- inline void onResponse(LocationError error, uint32_t /*id*/) {
+ inline void onResponse(LocationError error, uint32_t id) {
+ if (error != LOCATION_ERROR_SUCCESS) {
+ mAPI.removeSession(id);
+ }
mAPI.onStartBatchingCb(error);
}
LocationAPIClientBase& mAPI;
@@ -465,13 +471,7 @@ private:
public:
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++) {
- ids[i] = mAPI.mGeofenceBiDict.getId(sessions[i]);
- mAPI.mGeofenceBiDict.rmBySession(sessions[i]);
- }
- mAPI.onRemoveGeofencesCb(count, errors, ids);
- free(ids);
+ // No need to handle collectiveResponse, cbs already notified
}
LocationAPIClientBase& mAPI;
};
generated by cgit v1.2.3 (git 2.25.1) at 2025-10-19 23:46:40 +0000