MiPad4/android_device_xiaomi_sdm660-common
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Add jammer indication

Browse source 
Add AGC and jammer indication

Change-Id: I93641864338beec368e7a56b3a20b158ea892202
CRs-fixed: 2239155
This commit is contained in:
Mike Cailean 2018-06-07 16:54:35 -07:00
parent 4088ca58bc
commit 75cfd43bfd
10 changed files with 283 additions and 11 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
core/LocAdapterBase.cpp
View file

@ -80,7 +80,10 @@ void LocAdapterBase::
const GpsLocationExtended& locationExtended,
enum loc_sess_status status,
LocPosTechMask loc_technology_mask,
bool /*fromEngineHub*/) {
bool /*fromEngineHub*/,
GnssDataNotification* pDataNotify,
int msInWeek)
{
if (mLocAdapterProxyBase != NULL) {
mLocAdapterProxyBase->reportPositionEvent((UlpLocation&)location,
(GpsLocationExtended&)locationExtended,
@ -113,6 +116,11 @@ void LocAdapterBase::
reportNmeaEvent(const char* /*nmea*/, size_t /*length*/)
DEFAULT_IMPL()
void LocAdapterBase::
reportDataEvent(const GnssDataNotification& /*dataNotify*/,
int /*msInWeek*/)
DEFAULT_IMPL()
bool LocAdapterBase::
reportXtraServer(const char* /*url1*/, const char* /*url2*/,
const char* /*url3*/, const int /*maxlength*/)

10
core/LocAdapterBase.h
View file

@ -113,6 +113,11 @@ public:
mLocApi->updateEvtMask();
}
inline void updateNmeaMask(uint32_t mask)
{
mLocApi->updateNmeaMask(mask);
}
inline bool isFeatureSupported(uint8_t featureVal) {
return ContextBase::isFeatureSupported(featureVal);
}
@ -133,9 +138,12 @@ public:
const GpsLocationExtended& locationExtended,
enum loc_sess_status status,
LocPosTechMask loc_technology_mask,
bool fromEngineHub=false);
bool fromEngineHub = false,
GnssDataNotification* pDataNotify = nullptr,
int msInWeek = -1);
virtual void reportSvEvent(const GnssSvNotification& svNotify,
bool fromEngineHub=false);
virtual void reportDataEvent(const GnssDataNotification& dataNotify, int msInWeek);
virtual void reportNmeaEvent(const char* nmea, size_t length);
virtual void reportSvMeasurementEvent(GnssSvMeasurementSet &svMeasurementSet);
virtual void reportSvPolynomialEvent(GnssSvPolynomial &svPolynomial);

1
core/LocAdapterProxyBase.h
View file

@ -65,7 +65,6 @@ public:
GpsLocationExtended &locationExtended,
enum loc_sess_status status,
LocPosTechMask loc_technology_mask) {
(void)location;
(void)locationExtended;
(void)status;

38
core/LocApiBase.cpp
View file

@ -240,6 +240,30 @@ void LocApiBase::updateEvtMask()
mMsgTask->sendMsg(new LocOpenMsg(this));
}
void LocApiBase::updateNmeaMask(uint32_t mask)
{
struct LocSetNmeaMsg : public LocMsg {
LocApiBase* mLocApi;
uint32_t mMask;
inline LocSetNmeaMsg(LocApiBase* locApi, uint32_t mask) :
LocMsg(), mLocApi(locApi), mMask(mask)
{
locallog();
}
inline virtual void proc() const {
mLocApi->setNMEATypesSync(mMask);
}
inline void locallog() const {
LOC_LOGv("LocSyncNmea NmeaMask: %" PRIx32 "\n", mMask);
}
inline virtual void log() const {
locallog();
}
};
mMsgTask->sendMsg(new LocSetNmeaMsg(this, mask));
}
void LocApiBase::handleEngineUpEvent()
{
LocDualContext::injectFeatureConfig(mContext);
@ -259,7 +283,9 @@ void LocApiBase::handleEngineDownEvent()
void LocApiBase::reportPosition(UlpLocation& location,
GpsLocationExtended& locationExtended,
enum loc_sess_status status,
LocPosTechMask loc_technology_mask)
LocPosTechMask loc_technology_mask,
GnssDataNotification* pDataNotify,
int msInWeek)
{
// print the location info before delivering
LOC_LOGD("flags: %d\n source: %d\n latitude: %f\n longitude: %f\n "
@ -281,7 +307,9 @@ void LocApiBase::reportPosition(UlpLocation& location,
// loop through adapters, and deliver to all adapters.
TO_ALL_LOCADAPTERS(
mLocAdapters[i]->reportPositionEvent(location, locationExtended,
status, loc_technology_mask)
status, loc_technology_mask,
false,
pDataNotify, msInWeek)
);
}
@ -363,6 +391,12 @@ void LocApiBase::reportStatus(LocGpsStatusValue status)
TO_ALL_LOCADAPTERS(mLocAdapters[i]->reportStatus(status));
}
void LocApiBase::reportData(GnssDataNotification& dataNotify, int msInWeek)
{
// loop through adapters, and deliver to all adapters.
TO_ALL_LOCADAPTERS(mLocAdapters[i]->reportDataEvent(dataNotify, msInWeek));
}
void LocApiBase::reportNmea(const char* nmea, int length)
{
// loop through adapters, and deliver to all adapters.

7
core/LocApiBase.h
View file

@ -116,6 +116,7 @@ protected:
close();
LOC_API_ADAPTER_EVENT_MASK_T getEvtMask();
LOC_API_ADAPTER_EVENT_MASK_T mMask;
uint32_t mNmeaMask;
LocApiBase(LOC_API_ADAPTER_EVENT_MASK_T excludedMask,
ContextBase* context = NULL);
inline virtual ~LocApiBase() {
@ -154,12 +155,15 @@ public:
GpsLocationExtended& locationExtended,
enum loc_sess_status status,
LocPosTechMask loc_technology_mask =
LOC_POS_TECH_MASK_DEFAULT);
LOC_POS_TECH_MASK_DEFAULT,
GnssDataNotification* pDataNotify = nullptr,
int msInWeek = -1);
void reportSv(GnssSvNotification& svNotify);
void reportSvMeasurement(GnssSvMeasurementSet &svMeasurementSet);
void reportSvPolynomial(GnssSvPolynomial &svPolynomial);
void reportStatus(LocGpsStatusValue status);
void reportNmea(const char* nmea, int length);
void reportData(GnssDataNotification& dataNotify, int msInWeek);
void reportXtraServer(const char* url1, const char* url2,
const char* url3, const int maxlength);
void requestXtraData();
@ -262,6 +266,7 @@ public:
void updateEvtMask();
void updateNmeaMask(uint32_t mask);
virtual LocationError setGpsLockSync(GnssConfigGpsLock lock);

173
gnss/GnssAdapter.cpp
View file

@ -1896,6 +1896,11 @@ GnssAdapter::updateClientsEventMask()
if (it->second.gnssMeasurementsCb != nullptr) {
mask |= LOC_API_ADAPTER_BIT_GNSS_MEASUREMENT;
}
if (it->second.gnssDataCb != nullptr) {
mask |= LOC_API_ADAPTER_BIT_PARSED_POSITION_REPORT;
mask |= LOC_API_ADAPTER_BIT_NMEA_1HZ_REPORT;
updateNmeaMask(mNmeaMask | LOC_NMEA_MASK_DEBUG_V02);
}
}
/*
@ -2810,7 +2815,9 @@ GnssAdapter::reportPositionEvent(const UlpLocation& ulpLocation,
const GpsLocationExtended& locationExtended,
enum loc_sess_status status,
LocPosTechMask techMask,
bool fromEngineHub)
bool fromEngineHub,
GnssDataNotification* pDataNotify,
int msInWeek)
{
// if this event is called from QMI LOC API, then send report to engine hub
// if sending is successful, we return as we will wait for final report from engine hub
@ -2842,17 +2849,30 @@ GnssAdapter::reportPositionEvent(const UlpLocation& ulpLocation,
const GpsLocationExtended mLocationExtended;
loc_sess_status mStatus;
LocPosTechMask mTechMask;
GnssDataNotification mDataNotify;
int mMsInWeek;
bool mbIsDataValid;
inline MsgReportPosition(GnssAdapter& adapter,
const UlpLocation& ulpLocation,
const GpsLocationExtended& locationExtended,
loc_sess_status status,
LocPosTechMask techMask) :
LocPosTechMask techMask,
GnssDataNotification* pDataNotify,
int msInWeek) :
LocMsg(),
mAdapter(adapter),
mUlpLocation(ulpLocation),
mLocationExtended(locationExtended),
mStatus(status),
mTechMask(techMask) {}
mTechMask(techMask),
mMsInWeek(msInWeek) {
if (pDataNotify != nullptr) {
mDataNotify = *pDataNotify;
mbIsDataValid = true;
} else {
mbIsDataValid = false;
}
}
inline virtual void proc() const {
// extract bug report info - this returns true if consumed by systemstatus
SystemStatus* s = mAdapter.getSystemStatus();
@ -2861,10 +2881,19 @@ GnssAdapter::reportPositionEvent(const UlpLocation& ulpLocation,
s->eventPosition(mUlpLocation, mLocationExtended);
}
mAdapter.reportPosition(mUlpLocation, mLocationExtended, mStatus, mTechMask);
if (true == mbIsDataValid) {
if (-1 != mMsInWeek) {
mAdapter.getDataInformation((GnssDataNotification&)mDataNotify,
mMsInWeek);
}
mAdapter.reportData((GnssDataNotification&)mDataNotify);
}
}
};
sendMsg(new MsgReportPosition(*this, ulpLocation, locationExtended, status, techMask));
sendMsg(new MsgReportPosition(*this, ulpLocation, locationExtended,
status, techMask,
pDataNotify, msInWeek));
}
bool
@ -3100,6 +3129,54 @@ GnssAdapter::reportNmea(const char* nmea, size_t length)
}
}
void
GnssAdapter::reportDataEvent(const GnssDataNotification& dataNotify,
int msInWeek)
{
struct MsgReportData : public LocMsg {
GnssAdapter& mAdapter;
GnssDataNotification mDataNotify;
int mMsInWeek;
inline MsgReportData(GnssAdapter& adapter,
const GnssDataNotification& dataNotify,
int msInWeek) :
LocMsg(),
mAdapter(adapter),
mDataNotify(dataNotify),
mMsInWeek(msInWeek) {
}
inline virtual void proc() const {
if (-1 != mMsInWeek) {
mAdapter.getDataInformation((GnssDataNotification&)mDataNotify,
mMsInWeek);
}
mAdapter.reportData((GnssDataNotification&)mDataNotify);
}
};
sendMsg(new MsgReportData(*this, dataNotify, msInWeek));
}
void
GnssAdapter::reportData(GnssDataNotification& dataNotify)
{
for (int sig = 0; sig < GNSS_LOC_MAX_NUMBER_OF_SIGNAL_TYPES; sig++) {
if (GNSS_LOC_DATA_JAMMER_IND_BIT ==
(dataNotify.gnssDataMask[sig] & GNSS_LOC_DATA_JAMMER_IND_BIT)) {
LOC_LOGv("jammerInd[%d]=%f", sig, dataNotify.jammerInd[sig]);
}
if (GNSS_LOC_DATA_AGC_BIT ==
(dataNotify.gnssDataMask[sig] & GNSS_LOC_DATA_AGC_BIT)) {
LOC_LOGv("agc[%d]=%f", sig, dataNotify.agc[sig]);
}
}
for (auto it = mClientData.begin(); it != mClientData.end(); ++it) {
if (nullptr != it->second.gnssDataCb) {
it->second.gnssDataCb(dataNotify);
}
}
}
bool
GnssAdapter::requestNiNotifyEvent(const GnssNiNotification &notify, const void* data)
{
@ -3995,6 +4072,94 @@ GnssAdapter::getAgcInformation(GnssMeasurementsNotification& measurements, int m
}
}
/* get Data information from system status and fill it */
void
GnssAdapter::getDataInformation(GnssDataNotification& data, int msInWeek)
{
SystemStatus* systemstatus = getSystemStatus();
LOC_LOGV("%s]: msInWeek=%d", __func__, msInWeek);
if (nullptr != systemstatus) {
SystemStatusReports reports = {};
systemstatus->getReport(reports, true);
if ((!reports.mRfAndParams.empty()) && (!reports.mTimeAndClock.empty()) &&
(abs(msInWeek - (int)reports.mTimeAndClock.back().mGpsTowMs) < 2000)) {
for (int sig = GNSS_LOC_SIGNAL_TYPE_GPS_L1CA;
sig < GNSS_LOC_MAX_NUMBER_OF_SIGNAL_TYPES; sig++) {
data.gnssDataMask[sig] = 0;
data.jammerInd[sig] = 0.0;
data.agc[sig] = 0.0;
}
if (GNSS_INVALID_JAMMER_IND != reports.mRfAndParams.back().mAgcGps) {
data.gnssDataMask[GNSS_LOC_SIGNAL_TYPE_GPS_L1CA] |=
GNSS_LOC_DATA_AGC_BIT;
data.agc[GNSS_LOC_SIGNAL_TYPE_GPS_L1CA] =
reports.mRfAndParams.back().mAgcGps;
data.gnssDataMask[GNSS_LOC_SIGNAL_TYPE_QZSS_L1CA] |=
GNSS_LOC_DATA_AGC_BIT;
data.agc[GNSS_LOC_SIGNAL_TYPE_QZSS_L1CA] =
reports.mRfAndParams.back().mAgcGps;
data.gnssDataMask[GNSS_LOC_SIGNAL_TYPE_SBAS_L1_CA] |=
GNSS_LOC_DATA_AGC_BIT;
data.agc[GNSS_LOC_SIGNAL_TYPE_SBAS_L1_CA] =
reports.mRfAndParams.back().mAgcGps;
}
if (GNSS_INVALID_JAMMER_IND != reports.mRfAndParams.back().mJammerGps) {
data.gnssDataMask[GNSS_LOC_SIGNAL_TYPE_GPS_L1CA] |=
GNSS_LOC_DATA_JAMMER_IND_BIT;
data.jammerInd[GNSS_LOC_SIGNAL_TYPE_GPS_L1CA] =
(double)reports.mRfAndParams.back().mJammerGps;
data.gnssDataMask[GNSS_LOC_SIGNAL_TYPE_QZSS_L1CA] |=
GNSS_LOC_DATA_JAMMER_IND_BIT;
data.jammerInd[GNSS_LOC_SIGNAL_TYPE_QZSS_L1CA] =
(double)reports.mRfAndParams.back().mJammerGps;
data.gnssDataMask[GNSS_LOC_SIGNAL_TYPE_SBAS_L1_CA] |=
GNSS_LOC_DATA_JAMMER_IND_BIT;
data.jammerInd[GNSS_LOC_SIGNAL_TYPE_SBAS_L1_CA] =
(double)reports.mRfAndParams.back().mJammerGps;
}
if (GNSS_INVALID_JAMMER_IND != reports.mRfAndParams.back().mAgcGlo) {
data.gnssDataMask[GNSS_LOC_SIGNAL_TYPE_GLONASS_G1] |=
GNSS_LOC_DATA_AGC_BIT;
data.agc[GNSS_LOC_SIGNAL_TYPE_GLONASS_G1] =
reports.mRfAndParams.back().mAgcGlo;
}
if (GNSS_INVALID_JAMMER_IND != reports.mRfAndParams.back().mJammerGlo) {
data.gnssDataMask[GNSS_LOC_SIGNAL_TYPE_GLONASS_G1] |=
GNSS_LOC_DATA_JAMMER_IND_BIT;
data.jammerInd[GNSS_LOC_SIGNAL_TYPE_GLONASS_G1] =
(double)reports.mRfAndParams.back().mJammerGlo;
}
if (GNSS_INVALID_JAMMER_IND != reports.mRfAndParams.back().mAgcBds) {
data.gnssDataMask[GNSS_LOC_SIGNAL_TYPE_BEIDOU_B1_I] |=
GNSS_LOC_DATA_AGC_BIT;
data.agc[GNSS_LOC_SIGNAL_TYPE_BEIDOU_B1_I] =
reports.mRfAndParams.back().mAgcBds;
}
if (GNSS_INVALID_JAMMER_IND != reports.mRfAndParams.back().mJammerBds) {
data.gnssDataMask[GNSS_LOC_SIGNAL_TYPE_BEIDOU_B1_I] |=
GNSS_LOC_DATA_JAMMER_IND_BIT;
data.jammerInd[GNSS_LOC_SIGNAL_TYPE_BEIDOU_B1_I] =
(double)reports.mRfAndParams.back().mJammerBds;
}
if (GNSS_INVALID_JAMMER_IND != reports.mRfAndParams.back().mAgcGal) {
data.gnssDataMask[GNSS_LOC_SIGNAL_TYPE_GALILEO_E1_C] |=
GNSS_LOC_DATA_AGC_BIT;
data.agc[GNSS_LOC_SIGNAL_TYPE_GALILEO_E1_C] =
reports.mRfAndParams.back().mAgcGal;
}
if (GNSS_INVALID_JAMMER_IND != reports.mRfAndParams.back().mJammerGal) {
data.gnssDataMask[GNSS_LOC_SIGNAL_TYPE_GALILEO_E1_C] |=
GNSS_LOC_DATA_JAMMER_IND_BIT;
data.jammerInd[GNSS_LOC_SIGNAL_TYPE_GALILEO_E1_C] =
(double)reports.mRfAndParams.back().mJammerGal;
}
}
}
}
/* Callbacks registered with loc_net_iface library */
static void agpsOpenResultCb (bool isSuccess, AGpsExtType agpsType, const char* apn,
AGpsBearerType bearerType, void* userDataPtr) {

8
gnss/GnssAdapter.h
View file

@ -320,10 +320,13 @@ public:
const GpsLocationExtended& locationExtended,
enum loc_sess_status status,
LocPosTechMask techMask,
bool fromEngineHub=false);
bool fromEngineHub = false,
GnssDataNotification* pDataNotify = nullptr,
int msInWeek = -1);
virtual void reportSvEvent(const GnssSvNotification& svNotify,
bool fromEngineHub=false);
virtual void reportNmeaEvent(const char* nmea, size_t length);
virtual void reportDataEvent(const GnssDataNotification& dataNotify, int msInWeek);
virtual bool requestNiNotifyEvent(const GnssNiNotification& notify, const void* data);
virtual void reportGnssMeasurementDataEvent(const GnssMeasurementsNotification& measurements,
int msInWeek);
@ -345,6 +348,7 @@ public:
LocPosTechMask techMask);
void reportSv(GnssSvNotification& svNotify);
void reportNmea(const char* nmea, size_t length);
void reportData(GnssDataNotification& dataNotify);
bool requestNiNotify(const GnssNiNotification& notify, const void* data);
void reportGnssMeasurementData(const GnssMeasurementsNotification& measurements);
void reportGnssSvIdConfig(const GnssSvIdConfig& config);
@ -355,6 +359,8 @@ public:
bool getDebugReport(GnssDebugReport& report);
/* get AGC information from system status and fill it */
void getAgcInformation(GnssMeasurementsNotification& measurements, int msInWeek);
/* get Data information from system status and fill it */
void getDataInformation(GnssDataNotification& data, int msInWeek);
/*==== SYSTEM STATUS ================================================================*/
inline SystemStatus* getSystemStatus(void) { return mSystemStatus; }

1
location/LocationAPI.cpp
View file

@ -56,6 +56,7 @@ static bool needsGnssTrackingInfo(LocationCallbacks& locationCallbacks)
return (locationCallbacks.gnssLocationInfoCb != nullptr ||
locationCallbacks.gnssSvCb != nullptr ||
locationCallbacks.gnssNmeaCb != nullptr ||
locationCallbacks.gnssDataCb != nullptr ||
locationCallbacks.gnssMeasurementsCb != nullptr);
}

1
location/LocationAPIClientBase.h
View file

@ -239,6 +239,7 @@ public:
inline virtual void onCapabilitiesCb(LocationCapabilitiesMask /*capabilitiesMask*/) {}
inline virtual void onGnssNmeaCb(GnssNmeaNotification /*gnssNmeaNotification*/) {}
inline virtual void onGnssDataCb(GnssDataNotification /*gnssDataNotification*/) {}
inline virtual void onGnssMeasurementsCb(
GnssMeasurementsNotification /*gnssMeasurementsNotification*/) {}

45
location/LocationDataTypes.h
View file

@ -542,6 +542,36 @@ typedef enum
/**< QZSS satellite. */
} Gnss_LocSvSystemEnumType;
typedef enum {
GNSS_LOC_SIGNAL_TYPE_GPS_L1CA = 0, /**< GPS L1CA Signal */
GNSS_LOC_SIGNAL_TYPE_GPS_L1C = 1, /**< GPS L1C Signal */
GNSS_LOC_SIGNAL_TYPE_GPS_L2C_L = 2, /**< GPS L2C_L RF Band */
GNSS_LOC_SIGNAL_TYPE_GPS_L5_Q = 3, /**< GPS L5_Q RF Band */
GNSS_LOC_SIGNAL_TYPE_GLONASS_G1 = 4, /**< GLONASS G1 (L1OF) RF Band */
GNSS_LOC_SIGNAL_TYPE_GLONASS_G2 = 5, /**< GLONASS G2 (L2OF) RF Band */
GNSS_LOC_SIGNAL_TYPE_GALILEO_E1_C = 6, /**< GALILEO E1_C RF Band */
GNSS_LOC_SIGNAL_TYPE_GALILEO_E5A_Q = 7, /**< GALILEO E5A_Q RF Band */
GNSS_LOC_SIGNAL_TYPE_GALILEO_E5B_Q = 8, /**< GALILEO E5B_Q RF Band */
GNSS_LOC_SIGNAL_TYPE_BEIDOU_B1_I = 9, /**< BEIDOU B1_I RF Band */
GNSS_LOC_SIGNAL_TYPE_BEIDOU_B1C = 10, /**< BEIDOU B1C RF Band */
GNSS_LOC_SIGNAL_TYPE_BEIDOU_B2_I = 11, /**< BEIDOU B2_I RF Band */
GNSS_LOC_SIGNAL_TYPE_BEIDOU_B2A_I = 12, /**< BEIDOU B2A_I RF Band */
GNSS_LOC_SIGNAL_TYPE_QZSS_L1CA = 13, /**< QZSS L1CA RF Band */
GNSS_LOC_SIGNAL_TYPE_QZSS_L1S = 14, /**< QZSS L1S RF Band */
GNSS_LOC_SIGNAL_TYPE_QZSS_L2C_L = 15, /**< QZSS L2C_L RF Band */
GNSS_LOC_SIGNAL_TYPE_QZSS_L5_Q = 16, /**< QZSS L5_Q RF Band */
GNSS_LOC_SIGNAL_TYPE_SBAS_L1_CA = 17, /**< SBAS L1_CA RF Band */
GNSS_LOC_MAX_NUMBER_OF_SIGNAL_TYPES = 18 /**< Maximum number of signal types */
} Gnss_LocSignalEnumType;
typedef uint64_t GnssDataMask;
typedef enum {
// Jammer Indicator is available
GNSS_LOC_DATA_JAMMER_IND_BIT = (1ULL << 0),
// AGC is available
GNSS_LOC_DATA_AGC_BIT = (1ULL << 1)
} GnssDataBits;
typedef uint32_t GnssSystemTimeStructTypeFlags;
typedef enum {
GNSS_SYSTEM_TIME_WEEK_VALID = (1 << 0),
@ -958,6 +988,13 @@ typedef struct {
size_t length; // length of the nmea text
} GnssNmeaNotification;
typedef struct {
size_t size; // set to sizeof(GnssDataNotification)
GnssDataMask gnssDataMask[GNSS_LOC_MAX_NUMBER_OF_SIGNAL_TYPES]; // bitwise OR of GnssDataBits
double jammerInd[GNSS_LOC_MAX_NUMBER_OF_SIGNAL_TYPES]; // Jammer Indication
double agc[GNSS_LOC_MAX_NUMBER_OF_SIGNAL_TYPES]; // Automatic gain control
} GnssDataNotification;
typedef struct {
size_t size; // set to sizeof(GnssMeasurementsNotification)
size_t count; // number of items in GnssMeasurements array
@ -1152,6 +1189,13 @@ typedef std::function<void(
GnssNmeaNotification gnssNmeaNotification
)> gnssNmeaCallback;
/* Gives GNSS data, optional can be NULL
gnssDataCallback is called only during a tracking session
broadcasted to all clients, no matter if a session has started by client */
typedef std::function<void(
GnssDataNotification gnssDataNotification
)> gnssDataCallback;
/* Gives GNSS Measurements information, optional can be NULL
gnssMeasurementsCallback is called only during a tracking session
broadcasted to all clients, no matter if a session has started by client */
@ -1177,6 +1221,7 @@ typedef struct {
gnssNiCallback gnssNiCb; // optional
gnssSvCallback gnssSvCb; // optional
gnssNmeaCallback gnssNmeaCb; // optional
gnssDataCallback gnssDataCb; // optional
gnssMeasurementsCallback gnssMeasurementsCb; // optional
batchingStatusCallback batchingStatusCb; // optional
} LocationCallbacks;