psmattas/device_motorola_sanders
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

sanders: gps: update to LA.UM.7.6.r1-02000-89xx.0 tag

Browse Source
This commit is contained in:
therootlord
2018-09-12 13:45:48 -03:00
parent 8a6b5c05e7
commit 0a41b9dc1a
150 changed files with 4794 additions and 4130 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
gps/gnss/Agps.cpp
View File

@@ -30,7 +30,7 @@
#define LOG_TAG "LocSvc_Agps"
#include <Agps.h>
#include <platform_lib_includes.h>
#include <loc_pla.h>
#include <ContextBase.h>
#include <loc_timer.h>

20
gps/gnss/Agps.h
View File

@@ -34,7 +34,8 @@
#include <list>
#include <MsgTask.h>
#include <gps_extended_c.h>
#include <platform_lib_log_util.h>
#include <loc_pla.h>
#include <log_util.h>
/* ATL callback function pointers
* Passed in by Adapter to AgpsManager */
@@ -277,34 +278,29 @@ public:
mAgnssNif(NULL), mInternetNif(NULL), mDsNif(NULL) {}
/* Register callbacks */
void registerCallbacks(
AgnssStatusIpV4Cb frameworkStatusV4Cb,
AgpsAtlOpenStatusCb atlOpenStatusCb,
inline void registerATLCallbacks(AgpsAtlOpenStatusCb atlOpenStatusCb,
AgpsAtlCloseStatusCb atlCloseStatusCb,
AgpsDSClientInitFn dsClientInitFn,
AgpsDSClientOpenAndStartDataCallFn dsClientOpenAndStartDataCallFn,
AgpsDSClientStopDataCallFn dsClientStopDataCallFn,
AgpsDSClientCloseDataCallFn dsClientCloseDataCallFn,
AgpsDSClientReleaseFn dsClientReleaseFn,
SendMsgToAdapterMsgQueueFn sendMsgToAdapterQueueFn ){
mFrameworkStatusV4Cb = frameworkStatusV4Cb;
SendMsgToAdapterMsgQueueFn sendMsgToAdapterQueueFn) {
mAtlOpenStatusCb = atlOpenStatusCb;
mAtlCloseStatusCb = atlCloseStatusCb;
mDSClientInitFn = dsClientInitFn;
mDSClientOpenAndStartDataCallFn = dsClientOpenAndStartDataCallFn;
mDSClientStopDataCallFn = dsClientStopDataCallFn;
mDSClientCloseDataCallFn = dsClientCloseDataCallFn;
mDSClientReleaseFn = dsClientReleaseFn;
mSendMsgToAdapterQueueFn = sendMsgToAdapterQueueFn;
}
inline void registerFrameworkStatusCallback(AgnssStatusIpV4Cb frameworkStatusV4Cb) {
mFrameworkStatusV4Cb = frameworkStatusV4Cb;
}
/* Create all AGPS state machines */
void createAgpsStateMachines();

3
gps/gnss/Android.mk
View File

@@ -6,8 +6,7 @@ LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_MODULE := libgnss
LOCAL_MODULE_PATH_32 := $(TARGET_OUT_VENDOR)/lib
LOCAL_MODULE_PATH_64 := $(TARGET_OUT_VENDOR)/lib64
LOCAL_VENDOR_MODULE := true
LOCAL_MODULE_TAGS := optional
LOCAL_SHARED_LIBRARIES := \

556
gps/gnss/GnssAdapter.cpp
View File

@@ -74,12 +74,79 @@ GnssAdapter::GnssAdapter() :
mNiData(),
mAgpsManager(),
mAgpsCbInfo(),
mOdcpiRequestCb(nullptr),
mOdcpiRequestActive(false),
mOdcpiTimer(this),
mOdcpiRequest(),
mSystemStatus(SystemStatus::getInstance(mMsgTask)),
mServerUrl(""),
mServerUrl(":"),
mXtraObserver(mSystemStatus->getOsObserver(), mMsgTask)
{
LOC_LOGD("%s]: Constructor %p", __func__, this);
mUlpPositionMode.mode = LOC_POSITION_MODE_INVALID;
pthread_condattr_t condAttr;
pthread_condattr_init(&condAttr);
pthread_condattr_setclock(&condAttr, CLOCK_MONOTONIC);
pthread_cond_init(&mNiData.session.tCond, &condAttr);
pthread_cond_init(&mNiData.sessionEs.tCond, &condAttr);
pthread_condattr_destroy(&condAttr);
/* Set ATL open/close callbacks */
AgpsAtlOpenStatusCb atlOpenStatusCb =
[this](int handle, int isSuccess, char* apn,
AGpsBearerType bearerType, AGpsExtType agpsType) {
mLocApi->atlOpenStatus(
handle, isSuccess, apn, bearerType, agpsType);
};
AgpsAtlCloseStatusCb atlCloseStatusCb =
[this](int handle, int isSuccess) {
mLocApi->atlCloseStatus(handle, isSuccess);
};
/* Register DS Client APIs */
AgpsDSClientInitFn dsClientInitFn =
[this](bool isDueToSSR) {
return mLocApi->initDataServiceClient(isDueToSSR);
};
AgpsDSClientOpenAndStartDataCallFn dsClientOpenAndStartDataCallFn =
[this] {
return mLocApi->openAndStartDataCall();
};
AgpsDSClientStopDataCallFn dsClientStopDataCallFn =
[this] {
mLocApi->stopDataCall();
};
AgpsDSClientCloseDataCallFn dsClientCloseDataCallFn =
[this] {
mLocApi->closeDataCall();
};
AgpsDSClientReleaseFn dsClientReleaseFn =
[this] {
mLocApi->releaseDataServiceClient();
};
/* Send Msg function */
SendMsgToAdapterMsgQueueFn sendMsgFn =
[this](LocMsg* msg) {
sendMsg(msg);
};
mAgpsManager.registerATLCallbacks(atlOpenStatusCb, atlCloseStatusCb,
dsClientInitFn, dsClientOpenAndStartDataCallFn, dsClientStopDataCallFn,
dsClientCloseDataCallFn, dsClientReleaseFn, sendMsgFn);
readConfigCommand();
setConfigCommand();
initDefaultAgpsCommand();
@@ -522,6 +589,38 @@ GnssAdapter::readConfigCommand()
}
}
LocationError
GnssAdapter::setSuplHostServer(const char* server, int port)
{
LocationError locErr = LOCATION_ERROR_SUCCESS;
if (ContextBase::mGps_conf.AGPS_CONFIG_INJECT) {
char serverUrl[MAX_URL_LEN] = {};
int32_t length = -1;
const char noHost[] = "NONE";
locErr = LOCATION_ERROR_INVALID_PARAMETER;
if ((NULL == server) || (server[0] == 0) ||
(strncasecmp(noHost, server, sizeof(noHost)) == 0)) {
serverUrl[0] = '\0';
length = 0;
} else if (port > 0) {
length = snprintf(serverUrl, sizeof(serverUrl), "%s:%u", server, port);
}
if (length >= 0 && strncasecmp(getServerUrl().c_str(),
serverUrl, sizeof(serverUrl)) != 0) {
setServerUrl(serverUrl);
locErr = mLocApi->setServer(serverUrl, length);
if (locErr != LOCATION_ERROR_SUCCESS) {
LOC_LOGE("%s]:Error while setting SUPL_HOST server:%s",
__func__, serverUrl);
}
}
}
return locErr;
}
void
GnssAdapter::setConfigCommand()
{
@@ -541,6 +640,8 @@ GnssAdapter::setConfigCommand()
mApi.setLPPConfig(mAdapter.convertLppProfile(ContextBase::mGps_conf.LPP_PROFILE));
mApi.setAGLONASSProtocol(ContextBase::mGps_conf.A_GLONASS_POS_PROTOCOL_SELECT);
}
mAdapter.setSuplHostServer(ContextBase::mGps_conf.SUPL_HOST,
ContextBase::mGps_conf.SUPL_PORT);
mApi.setSensorControlConfig(ContextBase::mSap_conf.SENSOR_USAGE,
ContextBase::mSap_conf.SENSOR_PROVIDER);
mApi.setLPPeProtocolCp(
@@ -683,30 +784,8 @@ GnssAdapter::gnssUpdateConfigCommand(GnssConfig config)
}
if (mConfig.flags & GNSS_CONFIG_FLAGS_SET_ASSISTANCE_DATA_VALID_BIT) {
if (GNSS_ASSISTANCE_TYPE_SUPL == mConfig.assistanceServer.type) {
if (ContextBase::mGps_conf.AGPS_CONFIG_INJECT) {
char serverUrl[MAX_URL_LEN] = {};
int32_t length = 0;
const char noHost[] = "NONE";
if (NULL == mConfig.assistanceServer.hostName ||
strncasecmp(noHost,
mConfig.assistanceServer.hostName,
sizeof(noHost)) == 0) {
err = LOCATION_ERROR_INVALID_PARAMETER;
} else {
length = snprintf(serverUrl, sizeof(serverUrl), "%s:%u",
mConfig.assistanceServer.hostName,
mConfig.assistanceServer.port);
}
if (length > 0 && strncasecmp(mAdapter.getServerUrl().c_str(),
serverUrl, sizeof(serverUrl)) != 0) {
mAdapter.setServerUrl(serverUrl);
err = mApi.setServer(serverUrl, length);
}
} else {
err = LOCATION_ERROR_SUCCESS;
}
err = mAdapter.setSuplHostServer(mConfig.assistanceServer.hostName,
mConfig.assistanceServer.port);
} else if (GNSS_ASSISTANCE_TYPE_C2K == mConfig.assistanceServer.type) {
if (ContextBase::mGps_conf.AGPS_CONFIG_INJECT) {
struct in_addr addr;
@@ -859,7 +938,7 @@ GnssAdapter::gnssDeleteAidingDataCommand(GnssAidingData& data)
mAdapter.reportResponse(err, mSessionId);
SystemStatus* s = mAdapter.getSystemStatus();
if ((nullptr != s) && (mData.deleteAll)) {
s->setDefaultReport();
s->setDefaultGnssEngineStates();
}
}
};
@@ -868,6 +947,26 @@ GnssAdapter::gnssDeleteAidingDataCommand(GnssAidingData& data)
return sessionId;
}
void
GnssAdapter::gnssUpdateXtraThrottleCommand(const bool enabled)
{
LOC_LOGD("%s] enabled:%d", __func__, enabled);
struct UpdateXtraThrottleMsg : public LocMsg {
GnssAdapter& mAdapter;
const bool mEnabled;
inline UpdateXtraThrottleMsg(GnssAdapter& adapter, const bool enabled) :
LocMsg(),
mAdapter(adapter),
mEnabled(enabled) {}
inline virtual void proc() const {
mAdapter.mXtraObserver.updateXtraThrottle(mEnabled);
}
};
sendMsg(new UpdateXtraThrottleMsg(*this, enabled));
}
void
GnssAdapter::injectLocationCommand(double latitude, double longitude, float accuracy)
{
@@ -1077,7 +1176,16 @@ GnssAdapter::updateClientsEventMask()
mask |= LOC_API_ADAPTER_BIT_GNSS_MEASUREMENT;
mask |= LOC_API_ADAPTER_BIT_GNSS_SV_POLYNOMIAL_REPORT;
LOC_LOGD("%s]: Auto usecase, Enable MEAS/POLY - mask 0x%x", __func__, mask);
LOC_LOGD("%s]: Auto usecase, Enable MEAS/POLY - mask 0x%" PRIu64 "", __func__, mask);
}
if (mAgpsCbInfo.statusV4Cb != NULL) {
mask |= LOC_API_ADAPTER_BIT_LOCATION_SERVER_REQUEST;
}
// Add ODCPI handling
if (nullptr != mOdcpiRequestCb) {
mask |= LOC_API_ADAPTER_BIT_REQUEST_WIFI;
}
updateEvtMask(mask, LOC_REGISTRATION_MASK_SET);
@@ -1105,6 +1213,9 @@ GnssAdapter::restartSessions()
{
LOC_LOGD("%s]: ", __func__);
// odcpi session is no longer active after restart
mOdcpiRequestActive = false;
if (mTrackingSessions.empty()) {
return;
}
@@ -1943,7 +2054,8 @@ GnssAdapter::reportPositionEvent(const UlpLocation& ulpLocation,
inline virtual void proc() const {
// extract bug report info - this returns true if consumed by systemstatus
SystemStatus* s = mAdapter.getSystemStatus();
if ((nullptr != s) && (LOC_SESS_SUCCESS == mStatus)){
if ((nullptr != s) &&
((LOC_SESS_SUCCESS == mStatus) || (LOC_SESS_INTERMEDIATE == mStatus))){
s->eventPosition(mUlpLocation, mLocationExtended);
}
mAdapter.reportPosition(mUlpLocation, mLocationExtended, mStatus, mTechMask);
@@ -1953,34 +2065,41 @@ GnssAdapter::reportPositionEvent(const UlpLocation& ulpLocation,
sendMsg(new MsgReportPosition(*this, ulpLocation, locationExtended, status, techMask));
}
bool
GnssAdapter::needReport(const UlpLocation& ulpLocation,
enum loc_sess_status status,
LocPosTechMask techMask) {
bool reported = false;
if (LOC_SESS_SUCCESS == status) {
// this is a final fix
LocPosTechMask mask =
LOC_POS_TECH_MASK_SATELLITE | LOC_POS_TECH_MASK_SENSORS | LOC_POS_TECH_MASK_HYBRID;
// it is a Satellite fix or a sensor fix
reported = (mask & techMask);
} else if (LOC_SESS_INTERMEDIATE == status &&
LOC_SESS_INTERMEDIATE == ContextBase::mGps_conf.INTERMEDIATE_POS) {
// this is a intermediate fix and we accepte intermediate
// it is NOT the case that
// there is inaccuracy; and
// we care about inaccuracy; and
// the inaccuracy exceeds our tolerance
reported = !((ulpLocation.gpsLocation.flags & LOC_GPS_LOCATION_HAS_ACCURACY) &&
(ContextBase::mGps_conf.ACCURACY_THRES != 0) &&
(ulpLocation.gpsLocation.accuracy > ContextBase::mGps_conf.ACCURACY_THRES));
}
return reported;
}
void
GnssAdapter::reportPosition(const UlpLocation& ulpLocation,
const GpsLocationExtended& locationExtended,
enum loc_sess_status status,
LocPosTechMask techMask)
{
bool reported = false;
// what's in the if is... (line by line)
// 1. this is a final fix; and
// 1.1 it is a Satellite fix; or
// 1.2 it is a sensor fix
// 2. (must be intermediate fix... implicit)
// 2.1 we accepte intermediate; and
// 2.2 it is NOT the case that
// 2.2.1 there is inaccuracy; and
// 2.2.2 we care about inaccuracy; and
// 2.2.3 the inaccuracy exceeds our tolerance
if ((LOC_SESS_SUCCESS == status &&
((LOC_POS_TECH_MASK_SATELLITE |
LOC_POS_TECH_MASK_SENSORS |
LOC_POS_TECH_MASK_HYBRID) &
techMask)) ||
(LOC_SESS_INTERMEDIATE == ContextBase::mGps_conf.INTERMEDIATE_POS &&
!((ulpLocation.gpsLocation.flags &
LOC_GPS_LOCATION_HAS_ACCURACY) &&
(ContextBase::mGps_conf.ACCURACY_THRES != 0) &&
(ulpLocation.gpsLocation.accuracy >
ContextBase::mGps_conf.ACCURACY_THRES)))) {
bool reported = needReport(ulpLocation, status, techMask);
if (reported) {
if (locationExtended.flags & GPS_LOCATION_EXTENDED_HAS_GNSS_SV_USED_DATA) {
mGnssSvIdUsedInPosAvail = true;
mGnssSvIdUsedInPosition = locationExtended.gnss_sv_used_ids;
@@ -1997,7 +2116,6 @@ GnssAdapter::reportPosition(const UlpLocation& ulpLocation,
it->second.gnssLocationInfoCb(locationInfo);
}
}
reported = true;
}
if (NMEA_PROVIDER_AP == ContextBase::mGps_conf.NMEA_PROVIDER && !mTrackingSessions.empty()) {
@@ -2224,14 +2342,14 @@ static void* niThreadProc(void *args)
NiSession* pSession = (NiSession*)args;
int rc = 0; /* return code from pthread calls */
struct timeval present_time;
struct timespec present_time;
struct timespec expire_time;
pthread_mutex_lock(&pSession->tLock);
/* Calculate absolute expire time */
gettimeofday(&present_time, NULL);
clock_gettime(CLOCK_MONOTONIC, &present_time);
expire_time.tv_sec = present_time.tv_sec + pSession->respTimeLeft;
expire_time.tv_nsec = present_time.tv_usec * 1000;
expire_time.tv_nsec = present_time.tv_nsec;
LOC_LOGD("%s]: time out set for abs time %ld with delay %d sec",
__func__, (long)expire_time.tv_sec, pSession->respTimeLeft);
@@ -2356,7 +2474,7 @@ void
GnssAdapter::reportGnssMeasurementDataEvent(const GnssMeasurementsNotification& measurements,
int msInWeek)
{
LOC_LOGD("%s]: ", __func__);
LOC_LOGD("%s]: msInWeek=%d", __func__, msInWeek);
struct MsgReportGnssMeasurementData : public LocMsg {
GnssAdapter& mAdapter;
@@ -2407,19 +2525,170 @@ GnssAdapter::reportSvPolynomialEvent(GnssSvPolynomial &svPolynomial)
mUlpProxy->reportSvPolynomial(svPolynomial);
}
bool
GnssAdapter::reportOdcpiRequestEvent(OdcpiRequestInfo& request)
{
struct MsgReportOdcpiRequest : public LocMsg {
GnssAdapter& mAdapter;
OdcpiRequestInfo mOdcpiRequest;
inline MsgReportOdcpiRequest(GnssAdapter& adapter, OdcpiRequestInfo& request) :
LocMsg(),
mAdapter(adapter),
mOdcpiRequest(request) {}
inline virtual void proc() const {
mAdapter.reportOdcpiRequest(mOdcpiRequest);
}
};
sendMsg(new MsgReportOdcpiRequest(*this, request));
return true;
}
void GnssAdapter::reportOdcpiRequest(const OdcpiRequestInfo& request)
{
if (nullptr != mOdcpiRequestCb) {
LOC_LOGd("request: type %d, tbf %d, isEmergency %d"
" requestActive: %d timerActive: %d",
request.type, request.tbfMillis, request.isEmergencyMode,
mOdcpiRequestActive, mOdcpiTimer.isActive());
// ODCPI START and ODCPI STOP from modem can come in quick succession
// so the mOdcpiTimer helps avoid spamming the framework as well as
// extending the odcpi session past 30 seconds if needed
if (ODCPI_REQUEST_TYPE_START == request.type) {
if (false == mOdcpiRequestActive && false == mOdcpiTimer.isActive()) {
mOdcpiRequestCb(request);
mOdcpiRequestActive = true;
mOdcpiTimer.start();
// if the current active odcpi session is non-emergency, and the new
// odcpi request is emergency, replace the odcpi request with new request
// and restart the timer
} else if (false == mOdcpiRequest.isEmergencyMode &&
true == request.isEmergencyMode) {
mOdcpiRequestCb(request);
mOdcpiRequestActive = true;
if (true == mOdcpiTimer.isActive()) {
mOdcpiTimer.restart();
} else {
mOdcpiTimer.start();
}
// if ODCPI request is not active but the timer is active, then
// just update the active state and wait for timer to expire
// before requesting new ODCPI to avoid spamming ODCPI requests
} else if (false == mOdcpiRequestActive && true == mOdcpiTimer.isActive()) {
mOdcpiRequestActive = true;
}
mOdcpiRequest = request;
// the request is being stopped, but allow timer to expire first
// before stopping the timer just in case more ODCPI requests come
// to avoid spamming more odcpi requests to the framework
} else {
mOdcpiRequestActive = false;
}
} else {
LOC_LOGw("ODCPI request not supported");
}
}
void GnssAdapter::initOdcpiCommand(const OdcpiRequestCallback& callback)
{
struct MsgInitOdcpi : public LocMsg {
GnssAdapter& mAdapter;
OdcpiRequestCallback mOdcpiCb;
inline MsgInitOdcpi(GnssAdapter& adapter,
const OdcpiRequestCallback& callback) :
LocMsg(),
mAdapter(adapter),
mOdcpiCb(callback) {}
inline virtual void proc() const {
mAdapter.initOdcpi(mOdcpiCb);
}
};
sendMsg(new MsgInitOdcpi(*this, callback));
}
void GnssAdapter::initOdcpi(const OdcpiRequestCallback& callback)
{
mOdcpiRequestCb = callback;
/* Register for WIFI request */
updateEvtMask(LOC_API_ADAPTER_BIT_REQUEST_WIFI,
LOC_REGISTRATION_MASK_ENABLED);
}
void GnssAdapter::injectOdcpiCommand(const Location& location)
{
struct MsgInjectOdcpi : public LocMsg {
GnssAdapter& mAdapter;
Location mLocation;
inline MsgInjectOdcpi(GnssAdapter& adapter, const Location& location) :
LocMsg(),
mAdapter(adapter),
mLocation(location) {}
inline virtual void proc() const {
mAdapter.injectOdcpi(mLocation);
}
};
sendMsg(new MsgInjectOdcpi(*this, location));
}
void GnssAdapter::injectOdcpi(const Location& location)
{
LOC_LOGd("ODCPI Injection: requestActive: %d timerActive: %d"
"lat %.7f long %.7f",
mOdcpiRequestActive, mOdcpiTimer.isActive(),
location.latitude, location.longitude);
loc_api_adapter_err err = mLocApi->injectPosition(location);
if (LOC_API_ADAPTER_ERR_SUCCESS != err) {
LOC_LOGe("Inject Position API error %d", err);
}
}
// Called in the context of LocTimer thread
void OdcpiTimer::timeOutCallback()
{
if (nullptr != mAdapter) {
mAdapter->odcpiTimerExpireEvent();
}
}
// Called in the context of LocTimer thread
void GnssAdapter::odcpiTimerExpireEvent()
{
struct MsgOdcpiTimerExpire : public LocMsg {
GnssAdapter& mAdapter;
inline MsgOdcpiTimerExpire(GnssAdapter& adapter) :
LocMsg(),
mAdapter(adapter) {}
inline virtual void proc() const {
mAdapter.odcpiTimerExpire();
}
};
sendMsg(new MsgOdcpiTimerExpire(*this));
}
void GnssAdapter::odcpiTimerExpire()
{
LOC_LOGd("requestActive: %d timerActive: %d",
mOdcpiRequestActive, mOdcpiTimer.isActive());
// if ODCPI request is still active after timer
// expires, request again and restart timer
if (mOdcpiRequestActive) {
mOdcpiRequestCb(mOdcpiRequest);
mOdcpiTimer.restart();
} else {
mOdcpiTimer.stop();
}
}
void GnssAdapter::initDefaultAgps() {
LOC_LOGD("%s]: ", __func__);
LocationCapabilitiesMask mask = getCapabilities();
if (!(mask & LOCATION_CAPABILITIES_GNSS_MSB_BIT) &&
!(mask & LOCATION_CAPABILITIES_GNSS_MSA_BIT)) {
LOC_LOGI("%s]: Target does not support MSB and MSA.", __func__);
return;
}
void *handle = nullptr;
if ((handle = dlopen("libloc_net_iface.so", RTLD_NOW)) == nullptr) {
LOC_LOGE("%s]: libloc_net_iface.so not found !", __func__);
LOC_LOGD("%s]: libloc_net_iface.so not found !", __func__);
return;
}
@@ -2437,7 +2706,7 @@ void GnssAdapter::initDefaultAgps() {
return;
}
initAgpsCommand(cbInfo);
initAgps(cbInfo);
}
void GnssAdapter::initDefaultAgpsCommand() {
@@ -2448,7 +2717,6 @@ void GnssAdapter::initDefaultAgpsCommand() {
inline MsgInitDefaultAgps(GnssAdapter& adapter) :
LocMsg(),
mAdapter(adapter) {
LOC_LOGV("MsgInitDefaultAgps");
}
inline virtual void proc() const {
mAdapter.initDefaultAgps();
@@ -2459,141 +2727,53 @@ void GnssAdapter::initDefaultAgpsCommand() {
}
/* INIT LOC AGPS MANAGER */
void GnssAdapter::initAgps(const AgpsCbInfo& cbInfo) {
LOC_LOGD("%s]: mAgpsCbInfo.cbPriority - %d; cbInfo.cbPriority - %d",
__func__, mAgpsCbInfo.cbPriority, cbInfo.cbPriority)
if (!((ContextBase::mGps_conf.CAPABILITIES & LOC_GPS_CAPABILITY_MSB) ||
(ContextBase::mGps_conf.CAPABILITIES & LOC_GPS_CAPABILITY_MSA))) {
return;
}
if (mAgpsCbInfo.cbPriority > cbInfo.cbPriority) {
return;
} else {
mAgpsCbInfo = cbInfo;
mAgpsManager.registerFrameworkStatusCallback((AgnssStatusIpV4Cb)cbInfo.statusV4Cb);
mAgpsManager.createAgpsStateMachines();
/* Register for AGPS event mask */
updateEvtMask(LOC_API_ADAPTER_BIT_LOCATION_SERVER_REQUEST,
LOC_REGISTRATION_MASK_ENABLED);
}
}
void GnssAdapter::initAgpsCommand(const AgpsCbInfo& cbInfo){
LOC_LOGI("GnssAdapter::initAgpsCommand");
/* Set ATL open/close callbacks */
AgpsAtlOpenStatusCb atlOpenStatusCb =
[this](int handle, int isSuccess, char* apn,
AGpsBearerType bearerType, AGpsExtType agpsType) {
mLocApi->atlOpenStatus(
handle, isSuccess, apn, bearerType, agpsType);
};
AgpsAtlCloseStatusCb atlCloseStatusCb =
[this](int handle, int isSuccess) {
mLocApi->atlCloseStatus(handle, isSuccess);
};
/* Register DS Client APIs */
AgpsDSClientInitFn dsClientInitFn =
[this](bool isDueToSSR) {
return mLocApi->initDataServiceClient(isDueToSSR);
};
AgpsDSClientOpenAndStartDataCallFn dsClientOpenAndStartDataCallFn =
[this] {
return mLocApi->openAndStartDataCall();
};
AgpsDSClientStopDataCallFn dsClientStopDataCallFn =
[this] {
mLocApi->stopDataCall();
};
AgpsDSClientCloseDataCallFn dsClientCloseDataCallFn =
[this] {
mLocApi->closeDataCall();
};
AgpsDSClientReleaseFn dsClientReleaseFn =
[this] {
mLocApi->releaseDataServiceClient();
};
/* Send Msg function */
SendMsgToAdapterMsgQueueFn sendMsgFn =
[this](LocMsg* msg) {
sendMsg(msg);
};
/* Message to initialize AGPS module */
struct AgpsMsgInit: public LocMsg {
AgpsManager* mAgpsManager;
AgnssStatusIpV4Cb mFrameworkStatusV4Cb;
AgpsAtlOpenStatusCb mAtlOpenStatusCb;
AgpsAtlCloseStatusCb mAtlCloseStatusCb;
AgpsDSClientInitFn mDSClientInitFn;
AgpsDSClientOpenAndStartDataCallFn mDSClientOpenAndStartDataCallFn;
AgpsDSClientStopDataCallFn mDSClientStopDataCallFn;
AgpsDSClientCloseDataCallFn mDSClientCloseDataCallFn;
AgpsDSClientReleaseFn mDSClientReleaseFn;
SendMsgToAdapterMsgQueueFn mSendMsgFn;
const AgpsCbInfo mCbInfo;
GnssAdapter& mAdapter;
inline AgpsMsgInit(AgpsManager* agpsManager,
AgnssStatusIpV4Cb frameworkStatusV4Cb,
AgpsAtlOpenStatusCb atlOpenStatusCb,
AgpsAtlCloseStatusCb atlCloseStatusCb,
AgpsDSClientInitFn dsClientInitFn,
AgpsDSClientOpenAndStartDataCallFn dsClientOpenAndStartDataCallFn,
AgpsDSClientStopDataCallFn dsClientStopDataCallFn,
AgpsDSClientCloseDataCallFn dsClientCloseDataCallFn,
AgpsDSClientReleaseFn dsClientReleaseFn,
SendMsgToAdapterMsgQueueFn sendMsgFn,
inline AgpsMsgInit(const AgpsCbInfo& cbInfo,
GnssAdapter& adapter) :
LocMsg(), mAgpsManager(agpsManager), mFrameworkStatusV4Cb(
frameworkStatusV4Cb), mAtlOpenStatusCb(atlOpenStatusCb), mAtlCloseStatusCb(
atlCloseStatusCb), mDSClientInitFn(dsClientInitFn), mDSClientOpenAndStartDataCallFn(
dsClientOpenAndStartDataCallFn), mDSClientStopDataCallFn(
dsClientStopDataCallFn), mDSClientCloseDataCallFn(
dsClientCloseDataCallFn), mDSClientReleaseFn(
dsClientReleaseFn), mSendMsgFn(sendMsgFn),
mAdapter(adapter) {
LocMsg(), mCbInfo(cbInfo), mAdapter(adapter) {
LOC_LOGV("AgpsMsgInit");
}
inline virtual void proc() const {
LOC_LOGV("AgpsMsgInit::proc()");
mAgpsManager->registerCallbacks(mFrameworkStatusV4Cb, mAtlOpenStatusCb,
mAtlCloseStatusCb, mDSClientInitFn,
mDSClientOpenAndStartDataCallFn, mDSClientStopDataCallFn,
mDSClientCloseDataCallFn, mDSClientReleaseFn, mSendMsgFn);
mAgpsManager->createAgpsStateMachines();
/* Register for AGPS event mask */
mAdapter.updateEvtMask(LOC_API_ADAPTER_BIT_LOCATION_SERVER_REQUEST,
LOC_REGISTRATION_MASK_ENABLED);
mAdapter.initAgps(mCbInfo);
}
};
if (mAgpsCbInfo.cbPriority > cbInfo.cbPriority) {
LOC_LOGI("Higher priority AGPS CB already registered (%d > %d) !",
mAgpsCbInfo.cbPriority, cbInfo.cbPriority);
return;
} else {
mAgpsCbInfo = cbInfo;
LOC_LOGI("Registering AGPS CB %p with priority %d",
mAgpsCbInfo.statusV4Cb, mAgpsCbInfo.cbPriority);
}
/* Send message to initialize AGPS Manager */
sendMsg(new AgpsMsgInit(
&mAgpsManager,
(AgnssStatusIpV4Cb)cbInfo.statusV4Cb,
atlOpenStatusCb, atlCloseStatusCb,
dsClientInitFn, dsClientOpenAndStartDataCallFn,
dsClientStopDataCallFn, dsClientCloseDataCallFn,
dsClientReleaseFn,
sendMsgFn,
*this));
sendMsg(new AgpsMsgInit(cbInfo, *this));
}
/* GnssAdapter::requestATL
@@ -2993,6 +3173,9 @@ bool GnssAdapter::getDebugReport(GnssDebugReport& r)
r.mLocation.mLocation.longitude =
(double)(reports.mBestPosition.back().mBestLon) * RAD2DEG;
r.mLocation.mLocation.altitude = reports.mBestPosition.back().mBestAlt;
r.mLocation.mLocation.accuracy =
(double)(reports.mBestPosition.back().mBestHepe);
r.mLocation.mUtcReported = reports.mBestPosition.back().mUtcReported;
}
else {
@@ -3018,8 +3201,8 @@ bool GnssAdapter::getDebugReport(GnssDebugReport& r)
(int64_t)(reports.mTimeAndClock.back().mGpsTowMs);
r.mTime.timeUncertaintyNs =
(float)((reports.mTimeAndClock.back().mTimeUnc +
reports.mTimeAndClock.back().mLeapSecUnc)*1000);
((float)(reports.mTimeAndClock.back().mTimeUnc) +
(float)(reports.mTimeAndClock.back().mLeapSecUnc))*1000.0f;
r.mTime.frequencyUncertaintyNsPerSec =
(float)(reports.mTimeAndClock.back().mClockFreqBiasUnc);
LOC_LOGV("getDebugReport - timeestimate=%" PRIu64 " unc=%f frequnc=%f",
@@ -3052,12 +3235,12 @@ GnssAdapter::getAgcInformation(GnssMeasurementsNotification& measurements, int m
systemstatus->getReport(reports, true);
if ((!reports.mRfAndParams.empty()) && (!reports.mTimeAndClock.empty()) &&
reports.mTimeAndClock.back().mTimeValid &&
(abs(msInWeek - (int)reports.mTimeAndClock.back().mGpsTowMs) < 2000)) {
for (size_t i = 0; i < measurements.count; i++) {
switch (measurements.measurements[i].svType) {
case GNSS_SV_TYPE_GPS:
case GNSS_SV_TYPE_QZSS:
measurements.measurements[i].agcLevelDb =
reports.mRfAndParams.back().mAgcGps;
measurements.measurements[i].flags |=
@@ -3085,7 +3268,6 @@ GnssAdapter::getAgcInformation(GnssMeasurementsNotification& measurements, int m
GNSS_MEASUREMENTS_DATA_AUTOMATIC_GAIN_CONTROL_BIT;
break;
case GNSS_SV_TYPE_QZSS:
case GNSS_SV_TYPE_SBAS:
case GNSS_SV_TYPE_UNKNOWN:
default:

56
gps/gnss/GnssAdapter.h
View File

@@ -43,9 +43,39 @@
#define MAX_SATELLITES_IN_USE 12
#define LOC_NI_NO_RESPONSE_TIME 20
#define LOC_GPS_NI_RESPONSE_IGNORE 4
#define ODCPI_EXPECTED_INJECTION_TIME_MS 10000
class GnssAdapter;
class OdcpiTimer : public LocTimer {
public:
OdcpiTimer(GnssAdapter* adapter) :
LocTimer(), mAdapter(adapter), mActive(false) {}
inline void start() {
mActive = true;
LocTimer::start(ODCPI_EXPECTED_INJECTION_TIME_MS, false);
}
inline void stop() {
mActive = false;
LocTimer::stop();
}
inline void restart() {
stop();
start();
}
inline bool isActive() {
return mActive;
}
private:
// Override
virtual void timeOutCallback() override;
GnssAdapter* mAdapter;
bool mActive;
};
typedef struct {
pthread_t thread; /* NI thread */
uint32_t respTimeLeft; /* examine time for NI response */
@@ -81,6 +111,7 @@ namespace loc_core {
}
class GnssAdapter : public LocAdapterBase {
/* ==== ULP ============================================================================ */
UlpProxyBase* mUlpProxy;
@@ -102,10 +133,18 @@ class GnssAdapter : public LocAdapterBase {
/* ==== NI ============================================================================= */
NiData mNiData;
/* ==== AGPS ========================================================*/
/* ==== AGPS =========================================================================== */
// This must be initialized via initAgps()
AgpsManager mAgpsManager;
AgpsCbInfo mAgpsCbInfo;
void initAgps(const AgpsCbInfo& cbInfo);
/* ==== ODCPI ========================================================================== */
OdcpiRequestCallback mOdcpiRequestCb;
bool mOdcpiRequestActive;
OdcpiTimer mOdcpiTimer;
OdcpiRequestInfo mOdcpiRequest;
void odcpiTimerExpire();
/* === SystemStatus ===================================================================== */
SystemStatus* mSystemStatus;
@@ -151,6 +190,7 @@ public:
LocationCallbacks getClientCallbacks(LocationAPI* client);
LocationCapabilitiesMask getCapabilities();
void broadcastCapabilities(LocationCapabilitiesMask);
LocationError setSuplHostServer(const char* server, int port);
/* ==== TRACKING ======================================================================= */
/* ======== COMMANDS ====(Called from Client Thread)==================================== */
@@ -198,6 +238,7 @@ public:
void setConfigCommand();
uint32_t* gnssUpdateConfigCommand(GnssConfig config);
uint32_t gnssDeleteAidingDataCommand(GnssAidingData& data);
void gnssUpdateXtraThrottleCommand(const bool enabled);
void initDefaultAgpsCommand();
void initAgpsCommand(const AgpsCbInfo& cbInfo);
@@ -206,6 +247,15 @@ public:
void dataConnClosedCommand(AGpsExtType agpsType);
void dataConnFailedCommand(AGpsExtType agpsType);
/* ========= ODCPI ===================================================================== */
/* ======== COMMANDS ====(Called from Client Thread)==================================== */
void initOdcpiCommand(const OdcpiRequestCallback& callback);
void injectOdcpiCommand(const Location& location);
/* ======== UTILITIES ================================================================== */
void initOdcpi(const OdcpiRequestCallback& callback);
void injectOdcpi(const Location& location);
void odcpiTimerExpireEvent();
/* ======== RESPONSES ================================================================== */
void reportResponse(LocationError err, uint32_t sessionId);
void reportResponse(size_t count, LocationError* errs, uint32_t* ids);
@@ -239,8 +289,11 @@ public:
virtual bool requestSuplES(int connHandle);
virtual bool reportDataCallOpened();
virtual bool reportDataCallClosed();
virtual bool reportOdcpiRequestEvent(OdcpiRequestInfo& request);
/* ======== UTILITIES ================================================================= */
bool needReport(const UlpLocation& ulpLocation,
enum loc_sess_status status, LocPosTechMask techMask);
void reportPosition(const UlpLocation &ulpLocation,
const GpsLocationExtended &locationExtended,
enum loc_sess_status status,
@@ -249,6 +302,7 @@ public:
void reportNmea(const char* nmea, size_t length);
bool requestNiNotify(const GnssNiNotification& notify, const void* data);
void reportGnssMeasurementData(const GnssMeasurementsNotification& measurements);
void reportOdcpiRequest(const OdcpiRequestInfo& request);
/*======== GNSSDEBUG ================================================================*/
bool getDebugReport(GnssDebugReport& report);

84
gps/gnss/Makefile.am
View File

@@ -1,99 +1,31 @@
AM_CFLAGS = \
$(LOCPLA_CFLAGS) \
$(LOCHAL_CFLAGS) \
$(GPSUTILS_CFLAGS) \
$(LOCCORE_CFLAGS) \
-I./ \
-I../utils \
-I../core \
-I$(WORKSPACE)/hardware/qcom/gps/core/data-items \
-I../location \
-std=c++11
libgnss_la_SOURCES = \
location_gnss.cpp \
GnssAdapter.cpp \
XtraSystemStatusObserver.cpp \
Agps.cpp
if USE_GLIB
libgnss_la_CFLAGS = -DUSE_GLIB $(AM_CFLAGS) @GLIB_CFLAGS@
libgnss_la_LDFLAGS = -lstdc++ -lpthread @GLIB_LIBS@ -shared -avoid-version
libgnss_la_LDFLAGS = -lstdc++ -Wl,-z,defs -lpthread @GLIB_LIBS@ -shared -avoid-version
libgnss_la_CPPFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(AM_CPPFLAGS) @GLIB_CFLAGS@
else
libgnss_la_CFLAGS = $(AM_CFLAGS)
libgnss_la_LDFLAGS = -lpthread -shared -version-info 1:0:0
libgnss_la_LDFLAGS = -Wl,-z,defs -lpthread -shared -version-info 1:0:0
libgnss_la_CPPFLAGS = $(AM_CFLAGS) $(AM_CPPFLAGS)
endif
libgnss_la_LIBADD = -lstdc++ $(LOCPLA_LIBS) $(LOCHAL_LIBS)
libgnss_la_LIBADD = -lstdc++ $(GPSUTILS_LIBS) $(LOCCORE_LIBS)
#Create and Install libraries
#lib_LTLIBRARIES = libgnss.la
#library_includedir = $(pkgincludedir)
#pkgconfigdir = $(libdir)/pkgconfig
#pkgconfig_DATA = location-api.pc
#EXTRA_DIST = $(pkgconfig_DATA)
libloc_ds_api_CFLAGS = \
$(QMIF_CFLAGS) \
$(QMI_CFLAGS) \
$(DATA_CFLAGS) \
$(GPSUTILS_CFLAGS) \
-I$(WORKSPACE)/qcom-opensource/location/loc_api/ds_api
libloc_ds_api_la_SOURCES = \
$(WORKSPACE)/qcom-opensource/location/loc_api/ds_api/ds_client.c
if USE_GLIB
libloc_ds_api_la_CFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(libloc_ds_api_CFLAGS) @GLIB_CFLAGS@
libloc_ds_api_la_LDFLAGS = -lstdc++ -Wl,-z,defs -lpthread @GLIB_LIBS@ -shared -version-info 1:0:0
libloc_ds_api_la_LDFLAGS += -Wl,--export-dynamic
libloc_ds_api_la_CPPFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(libloc_ds_api_CFLAGS) $(AM_CPPFLAGS) @GLIB_CFLAGS@
else
libloc_ds_api_la_CFLAGS = $(AM_CFLAGS) $(libloc_ds_api_CFLAGS)
libloc_ds_api_la_LDFLAGS = -lstdc++ -Wl,-z,defs -lpthread -Wl,--export-dynamic -shared -version-info 1:0:0
libloc_ds_api_la_LDFLAGS += -Wl,--export-dynamic
libloc_ds_api_la_CPPFLAGS = $(AM_CFLAGS) $(AM_CPPFLAGS) $(libloc_ds_api_CFLAGS)
endif
libloc_ds_api_la_LIBADD = -lstdc++ $(QMIF_LIBS) -lqmiservices -ldsi_netctrl $(GPSUTILS_LIBS) $(LOCPLA_LIBS)
libloc_api_v02_CFLAGS = \
$(QMIF_CFLAGS) \
$(GPSUTILS_CFLAGS) \
-I$(WORKSPACE)/qcom-opensource/location/loc_api/ds_api \
-I$(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02
libloc_api_v02_la_SOURCES = \
$(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/LocApiV02.cpp \
$(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/loc_api_v02_log.c \
$(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/loc_api_v02_client.c \
$(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/loc_api_sync_req.c \
$(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/location_service_v02.c
if USE_GLIB
libloc_api_v02_la_CFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(libloc_api_v02_CFLAGS) @GLIB_CFLAGS@
libloc_api_v02_la_LDFLAGS = -lstdc++ -g -Wl,-z,defs -lpthread @GLIB_LIBS@ -shared -version-info 1:0:0
libloc_api_v02_la_CPPFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(libloc_api_v02_CFLAGS) $(AM_CPPFLAGS) @GLIB_CFLAGS@
else
libloc_api_v02_la_CFLAGS = $(AM_CFLAGS) $(libloc_api_v02_CFLAGS)
libloc_api_v02_la_LDFLAGS = -lstdc++ -Wl,-z,defs -lpthread -shared -version-info 1:0:0
libloc_api_v02_la_CPPFLAGS = $(AM_CFLAGS) $(AM_CPPFLAGS) $(libloc_api_v02_CFLAGS)
endif
libloc_api_v02_la_CXXFLAGS = -std=c++0x
libloc_api_v02_la_LIBADD = -lstdc++ -lqmi_cci -lqmi_common_so $(QMIF_LIBS) $(GPSUTILS_LIBS) $(LOCPLA_LIBS) ../core/libloc_core.la libloc_ds_api.la
library_include_HEADERS = \
$(WORKSPACE)/qcom-opensource/location/loc_api/ds_api/ds_client.h \
$(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/location_service_v02.h \
$(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/loc_api_v02_log.h \
$(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/loc_api_v02_client.h \
$(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/loc_api_sync_req.h \
$(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/LocApiV02.h \
$(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/loc_util_log.h
library_includedir = $(pkgincludedir)
#Create and Install libraries
lib_LTLIBRARIES = libgnss.la libloc_ds_api.la libloc_api_v02.la
lib_LTLIBRARIES = libgnss.la

165
gps/gnss/XtraSystemStatusObserver.cpp
View File

@@ -47,97 +47,125 @@
#include <LocAdapterBase.h>
#include <DataItemId.h>
#include <DataItemsFactoryProxy.h>
#include <DataItemConcreteTypesBase.h>
using namespace loc_core;
#define XTRA_HAL_SOCKET_NAME "/data/vendor/location/xtra/socket_hal_xtra"
#ifdef LOG_TAG
#undef LOG_TAG
#endif
#define LOG_TAG "LocSvc_XSSO"
bool XtraSystemStatusObserver::updateLockStatus(uint32_t lock) {
mGpsLock = lock;
if (!mReqStatusReceived) {
return true;
}
stringstream ss;
ss << "gpslock";
ss << " " << lock;
ss << "\n"; // append seperator
return ( sendEvent(ss) );
return ( send(LOC_IPC_XTRA, ss.str()) );
}
bool XtraSystemStatusObserver::updateConnectionStatus(bool connected, uint32_t type) {
bool XtraSystemStatusObserver::updateConnections(uint64_t allConnections) {
mIsConnectivityStatusKnown = true;
mConnections = allConnections;
if (!mReqStatusReceived) {
return true;
}
stringstream ss;
ss << "connection";
ss << " " << (connected ? "1" : "0");
ss << " " << (int)type;
ss << "\n"; // append seperator
return ( sendEvent(ss) );
ss << " " << mConnections;
return ( send(LOC_IPC_XTRA, ss.str()) );
}
bool XtraSystemStatusObserver::updateTac(const string& tac) {
mTac = tac;
if (!mReqStatusReceived) {
return true;
}
stringstream ss;
ss << "tac";
ss << " " << tac.c_str();
ss << "\n"; // append seperator
return ( sendEvent(ss) );
return ( send(LOC_IPC_XTRA, ss.str()) );
}
bool XtraSystemStatusObserver::updateMccMnc(const string& mccmnc) {
mMccmnc = mccmnc;
if (!mReqStatusReceived) {
return true;
}
stringstream ss;
ss << "mncmcc";
ss << " " << mccmnc.c_str();
ss << "\n"; // append seperator
return ( sendEvent(ss) );
return ( send(LOC_IPC_XTRA, ss.str()) );
}
bool XtraSystemStatusObserver::sendEvent(const stringstream& event) {
int socketFd = createSocket();
if (socketFd < 0) {
LOC_LOGe("XTRA unreachable. sending failed.");
return false;
bool XtraSystemStatusObserver::updateXtraThrottle(const bool enabled) {
mXtraThrottle = enabled;
if (!mReqStatusReceived) {
return true;
}
const string& data = event.str();
int remain = data.length();
ssize_t sent = 0;
while (remain > 0 &&
(sent = ::send(socketFd, data.c_str() + (data.length() - remain),
remain, MSG_NOSIGNAL)) > 0) {
remain -= sent;
}
if (sent < 0) {
LOC_LOGe("sending error. reason:%s", strerror(errno));
}
closeSocket(socketFd);
return (remain == 0);
stringstream ss;
ss << "xtrathrottle";
ss << " " << (enabled ? 1 : 0);
return ( send(LOC_IPC_XTRA, ss.str()) );
}
inline bool XtraSystemStatusObserver::onStatusRequested(int32_t xtraStatusUpdated) {
mReqStatusReceived = true;
int XtraSystemStatusObserver::createSocket() {
int socketFd = -1;
if ((socketFd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) {
LOC_LOGe("create socket error. reason:%s", strerror(errno));
} else {
const char* socketPath = XTRA_HAL_SOCKET_NAME ;
struct sockaddr_un addr = { .sun_family = AF_UNIX };
snprintf(addr.sun_path, sizeof(addr.sun_path), "%s", socketPath);
if (::connect(socketFd, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
LOC_LOGe("cannot connect to XTRA. reason:%s", strerror(errno));
if (::close(socketFd)) {
LOC_LOGe("close socket error. reason:%s", strerror(errno));
}
socketFd = -1;
}
if (xtraStatusUpdated) {
return true;
}
return socketFd;
stringstream ss;
ss << "respondStatus" << endl;
(mGpsLock == -1 ? ss : ss << mGpsLock) << endl << mConnections << endl
<< mTac << endl << mMccmnc << endl << mIsConnectivityStatusKnown;
return ( send(LOC_IPC_XTRA, ss.str()) );
}
void XtraSystemStatusObserver::closeSocket(const int socketFd) {
if (socketFd >= 0) {
if(::close(socketFd)) {
LOC_LOGe("close socket error. reason:%s", strerror(errno));
}
void XtraSystemStatusObserver::onReceive(const std::string& data) {
if (!strncmp(data.c_str(), "ping", sizeof("ping") - 1)) {
LOC_LOGd("ping received");
#ifdef USE_GLIB
} else if (!strncmp(data.c_str(), "connectBackhaul", sizeof("connectBackhaul") - 1)) {
mSystemStatusObsrvr->connectBackhaul();
} else if (!strncmp(data.c_str(), "disconnectBackhaul", sizeof("disconnectBackhaul") - 1)) {
mSystemStatusObsrvr->disconnectBackhaul();
#endif
} else if (!strncmp(data.c_str(), "requestStatus", sizeof("requestStatus") - 1)) {
int32_t xtraStatusUpdated = 0;
sscanf(data.c_str(), "%*s %d", &xtraStatusUpdated);
struct HandleStatusRequestMsg : public LocMsg {
XtraSystemStatusObserver& mXSSO;
int32_t mXtraStatusUpdated;
inline HandleStatusRequestMsg(XtraSystemStatusObserver& xsso,
int32_t xtraStatusUpdated) :
mXSSO(xsso), mXtraStatusUpdated(xtraStatusUpdated) {}
inline void proc() const override { mXSSO.onStatusRequested(mXtraStatusUpdated); }
};
mMsgTask->sendMsg(new (nothrow) HandleStatusRequestMsg(*this, xtraStatusUpdated));
} else {
LOC_LOGw("unknown event: %s", data.c_str());
}
}
@@ -169,11 +197,11 @@ void XtraSystemStatusObserver::getName(string& name)
void XtraSystemStatusObserver::notify(const list<IDataItemCore*>& dlist)
{
struct handleOsObserverUpdateMsg : public LocMsg {
struct HandleOsObserverUpdateMsg : public LocMsg {
XtraSystemStatusObserver* mXtraSysStatObj;
list <IDataItemCore*> mDataItemList;
inline handleOsObserverUpdateMsg(XtraSystemStatusObserver* xtraSysStatObs,
inline HandleOsObserverUpdateMsg(XtraSystemStatusObserver* xtraSysStatObs,
const list<IDataItemCore*>& dataItemList) :
mXtraSysStatObj(xtraSysStatObs) {
for (auto eachItem : dataItemList) {
@@ -189,7 +217,7 @@ void XtraSystemStatusObserver::notify(const list<IDataItemCore*>& dlist)
}
}
inline ~handleOsObserverUpdateMsg() {
inline ~HandleOsObserverUpdateMsg() {
for (auto each : mDataItemList) {
delete each;
}
@@ -201,23 +229,24 @@ void XtraSystemStatusObserver::notify(const list<IDataItemCore*>& dlist)
{
case NETWORKINFO_DATA_ITEM_ID:
{
SystemStatusNetworkInfo* networkInfo =
reinterpret_cast<SystemStatusNetworkInfo*>(each);
mXtraSysStatObj->updateConnectionStatus(networkInfo->mConnected,
networkInfo->mType);
NetworkInfoDataItemBase* networkInfo =
static_cast<NetworkInfoDataItemBase*>(each);
mXtraSysStatObj->updateConnections(networkInfo->getAllTypes());
}
break;
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;
@@ -228,7 +257,5 @@ void XtraSystemStatusObserver::notify(const list<IDataItemCore*>& dlist)
}
}
};
mMsgTask->sendMsg(new (nothrow) handleOsObserverUpdateMsg(this, dlist));
mMsgTask->sendMsg(new (nothrow) HandleOsObserverUpdateMsg(this, dlist));
}

44
gps/gnss/XtraSystemStatusObserver.h
View File

@@ -31,41 +31,67 @@
#include <cinttypes>
#include <MsgTask.h>
#include <LocIpc.h>
#include <LocTimer.h>
using namespace std;
using loc_core::IOsObserver;
using loc_core::IDataItemObserver;
using loc_core::IDataItemCore;
using loc_util::LocIpc;
class XtraSystemStatusObserver : public IDataItemObserver {
class XtraSystemStatusObserver : public IDataItemObserver, public LocIpc{
public :
// constructor & destructor
inline XtraSystemStatusObserver(IOsObserver* sysStatObs, const MsgTask* msgTask):
mSystemStatusObsrvr(sysStatObs), mMsgTask(msgTask) {
mSystemStatusObsrvr(sysStatObs), mMsgTask(msgTask),
mGpsLock(-1), mConnections(0), mXtraThrottle(true), mReqStatusReceived(false),
mDelayLocTimer(*this), mIsConnectivityStatusKnown (false) {
subscribe(true);
startListeningNonBlocking(LOC_IPC_HAL);
mDelayLocTimer.start(100 /*.1 sec*/, false);
}
inline virtual ~XtraSystemStatusObserver() {
subscribe(false);
stopListening();
}
inline XtraSystemStatusObserver() {};
inline virtual ~XtraSystemStatusObserver() { subscribe(false); }
// IDataItemObserver overrides
inline virtual void getName(string& name);
virtual void notify(const list<IDataItemCore*>& dlist);
bool updateLockStatus(uint32_t lock);
bool updateConnectionStatus(bool connected, uint32_t type);
bool updateConnections(uint64_t allConnections);
bool updateTac(const string& tac);
bool updateMccMnc(const string& mccmnc);
bool updateXtraThrottle(const bool enabled);
inline const MsgTask* getMsgTask() { return mMsgTask; }
void subscribe(bool yes);
protected:
void onReceive(const std::string& data) override;
private:
int createSocket();
void closeSocket(const int32_t socketFd);
bool sendEvent(const stringstream& event);
IOsObserver* mSystemStatusObsrvr;
const MsgTask* mMsgTask;
int32_t mGpsLock;
uint64_t mConnections;
string mTac;
string mMccmnc;
bool mXtraThrottle;
bool mReqStatusReceived;
bool mIsConnectivityStatusKnown;
class DelayLocTimer : public LocTimer {
XtraSystemStatusObserver& mXSSO;
public:
DelayLocTimer(XtraSystemStatusObserver& xsso) : mXSSO(xsso) {}
void timeOutCallback() override {
mXSSO.send(LOC_IPC_XTRA, "halinit");
}
} mDelayLocTimer;
bool onStatusRequested(int32_t xtraStatusUpdated);
};
#endif

33
gps/gnss/location_gnss.cpp
View File

@@ -45,6 +45,7 @@ static void stopTracking(LocationAPI* client, uint32_t id);
static void gnssNiResponse(LocationAPI* client, uint32_t id, GnssNiResponse response);
static uint32_t gnssDeleteAidingData(GnssAidingData& data);
static void gnssUpdateXtraThrottle(const bool enabled);
static void setControlCallbacks(LocationControlCallbacks& controlCallbacks);
static uint32_t enable(LocationTechnologyType techType);
@@ -59,7 +60,10 @@ static void agpsDataConnOpen(AGpsExtType agpsType, const char* apnName, int apnL
static void agpsDataConnClosed(AGpsExtType agpsType);
static void agpsDataConnFailed(AGpsExtType agpsType);
static void getDebugReport(GnssDebugReport& report);
static void updateConnectionStatus(bool connected, uint8_t type);
static void updateConnectionStatus(bool connected, int8_t type);
static void odcpiInit(const OdcpiRequestCallback& callback);
static void odcpiInject(const Location& location);
static const GnssInterface gGnssInterface = {
sizeof(GnssInterface),
@@ -77,6 +81,7 @@ static const GnssInterface gGnssInterface = {
disable,
gnssUpdateConfig,
gnssDeleteAidingData,
gnssUpdateXtraThrottle,
injectLocation,
injectTime,
agpsInit,
@@ -85,6 +90,8 @@ static const GnssInterface gGnssInterface = {
agpsDataConnFailed,
getDebugReport,
updateConnectionStatus,
odcpiInit,
odcpiInject,
};
#ifndef DEBUG_X86
@@ -203,6 +210,13 @@ static uint32_t gnssDeleteAidingData(GnssAidingData& data)
}
}
static void gnssUpdateXtraThrottle(const bool enabled)
{
if (NULL != gGnssAdapter) {
gGnssAdapter->gnssUpdateXtraThrottleCommand(enabled);
}
}
static void injectLocation(double latitude, double longitude, float accuracy)
{
if (NULL != gGnssAdapter) {
@@ -251,8 +265,23 @@ static void getDebugReport(GnssDebugReport& report) {
}
}
static void updateConnectionStatus(bool connected, uint8_t type) {
static void updateConnectionStatus(bool connected, int8_t type) {
if (NULL != gGnssAdapter) {
gGnssAdapter->getSystemStatus()->eventConnectionStatus(connected, type);
}
}
static void odcpiInit(const OdcpiRequestCallback& callback)
{
if (NULL != gGnssAdapter) {
gGnssAdapter->initOdcpiCommand(callback);
}
}
static void odcpiInject(const Location& location)
{
if (NULL != gGnssAdapter) {
gGnssAdapter->injectOdcpiCommand(location);
}
}