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

Merge "Merge tag 'AU_LINUX_ANDROID_LA.AF.1.1.05.00.02.164.175' into 111"

Browse source
This commit is contained in:
Linux Build Service Account 2015-02-14 06:58:27 -08:00 committed by Gerrit - the friendly Code Review server
commit a0e8ab95f1
13 changed files with 427 additions and 69 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
core/LocAdapterBase.cpp
View file

@ -139,4 +139,8 @@ DEFAULT_IMPL(false)
void LocAdapterBase::
shutdown()
DEFAULT_IMPL()
void LocAdapterBase::
reportGpsMeasurementData(GpsData &gpsMeasurementData)
DEFAULT_IMPL()
} // namespace loc_core

1
core/LocAdapterBase.h
View file

@ -114,6 +114,7 @@ public:
inline virtual bool isInSession() { return false; }
virtual void shutdown();
ContextBase* getContext() const { return mContext; }
virtual void reportGpsMeasurementData(GpsData &gpsMeasurementData);
};
} // namespace loc_core

40
core/LocApiBase.cpp
View file

@ -232,6 +232,17 @@ void LocApiBase::reportPosition(UlpLocation &location,
enum loc_sess_status status,
LocPosTechMask loc_technology_mask)
{
// print the location info before delivering
LOC_LOGV("flags: %d\n source: %d\n latitude: %f\n longitude: %f\n "
"altitude: %f\n speed: %f\n bearing: %f\n accuracy: %f\n "
"timestamp: %lld\n rawDataSize: %d\n rawData: %p\n "
"Session status: %d\n Technology mask: %u",
location.gpsLocation.flags, location.position_source,
location.gpsLocation.latitude, location.gpsLocation.longitude,
location.gpsLocation.altitude, location.gpsLocation.speed,
location.gpsLocation.bearing, location.gpsLocation.accuracy,
location.gpsLocation.timestamp, location.rawDataSize,
location.rawData, status, loc_technology_mask);
// loop through adapters, and deliver to all adapters.
TO_ALL_LOCADAPTERS(
mLocAdapters[i]->reportPosition(location,
@ -246,6 +257,19 @@ void LocApiBase::reportSv(GpsSvStatus &svStatus,
GpsLocationExtended &locationExtended,
void* svExt)
{
// print the SV info before delivering
LOC_LOGV("num sv: %d\n ephemeris mask: %dxn almanac mask: %x\n used"
" in fix mask: %x\n sv: prn snr elevation azimuth",
svStatus.num_svs, svStatus.ephemeris_mask,
svStatus.almanac_mask, svStatus.used_in_fix_mask);
for (int i = 0; i < svStatus.num_svs && i < GPS_MAX_SVS; i++) {
LOC_LOGV(" %d: %d %f %f %f",
i,
svStatus.sv_list[i].prn,
svStatus.sv_list[i].snr,
svStatus.sv_list[i].elevation,
svStatus.sv_list[i].azimuth);
}
// loop through adapters, and deliver to all adapters.
TO_ALL_LOCADAPTERS(
mLocAdapters[i]->reportSv(svStatus,
@ -355,6 +379,12 @@ void* LocApiBase :: getSibling()
LocApiProxyBase* LocApiBase :: getLocApiProxy()
DEFAULT_IMPL(NULL)
void LocApiBase::reportGpsMeasurementData(GpsData &gpsMeasurementData)
{
// loop through adapters, and deliver to all adapters.
TO_ALL_LOCADAPTERS(mLocAdapters[i]->reportGpsMeasurementData(gpsMeasurementData));
}
enum loc_api_adapter_err LocApiBase::
open(LOC_API_ADAPTER_EVENT_MASK_T mask)
DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
@ -518,4 +548,14 @@ DEFAULT_IMPL(-1)
enum loc_api_adapter_err LocApiBase::
setXtraVersionCheck(enum xtra_version_check check)
DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
int LocApiBase::
updateRegistrationMask(LOC_API_ADAPTER_EVENT_MASK_T event,
loc_registration_mask_status isEnabled)
DEFAULT_IMPL(-1)
bool LocApiBase::
gnssConstellationConfig()
DEFAULT_IMPL(false)
} // namespace loc_core

12
core/LocApiBase.h
View file

@ -132,6 +132,7 @@ public:
void reportDataCallClosed();
void requestNiNotify(GpsNiNotification &notify, const void* data);
void saveSupportedMsgList(uint64_t supportedMsgList);
void reportGpsMeasurementData(GpsData &gpsMeasurementData);
// downward calls
// All below functions are to be defined by adapter specific modules:
@ -239,7 +240,18 @@ public:
-1 on failure
*/
virtual int getGpsLock(void);
virtual enum loc_api_adapter_err setXtraVersionCheck(enum xtra_version_check check);
/*
Update gps reporting events
*/
virtual int updateRegistrationMask(LOC_API_ADAPTER_EVENT_MASK_T event,
loc_registration_mask_status isEnabled);
/*
Check if the modem support the service
*/
virtual bool gnssConstellationConfig();
};
typedef LocApiBase* (getLocApi_t)(const MsgTask* msgTask,

3
core/LocDualContext.cpp
View file

@ -50,7 +50,8 @@ LocDualContext::mBgExclMask =
LOC_API_ADAPTER_BIT_NMEA_POSITION_REPORT |
LOC_API_ADAPTER_BIT_IOCTL_REPORT |
LOC_API_ADAPTER_BIT_STATUS_REPORT |
LOC_API_ADAPTER_BIT_GEOFENCE_GEN_ALERT);
LOC_API_ADAPTER_BIT_GEOFENCE_GEN_ALERT |
LOC_API_ADAPTER_BIT_GNSS_MEASUREMENT);
const MsgTask* LocDualContext::mMsgTask = NULL;
ContextBase* LocDualContext::mFgContext = NULL;

6
core/gps_extended_c.h
View file

@ -349,6 +349,9 @@ enum loc_api_adapter_event_index {
LOC_API_ADAPTER_BATCHED_GENFENCE_BREACH_REPORT, //
LOC_API_ADAPTER_GNSS_MEASUREMENT_REPORT, //GNSS Measurement Report
LOC_API_ADAPTER_GNSS_SV_POLYNOMIAL_REPORT, //GNSS SV Polynomial Report
LOC_API_ADAPTER_GDT_UPLOAD_BEGIN_REQ, // GDT upload start request
LOC_API_ADAPTER_GDT_UPLOAD_END_REQ, // GDT upload end request
LOC_API_ADAPTER_GNSS_MEASUREMENT, // GNSS Measurement report
LOC_API_ADAPTER_EVENT_MAX
};
@ -377,6 +380,9 @@ enum loc_api_adapter_event_index {
#define LOC_API_ADAPTER_BIT_BATCHED_POSITION_REPORT (1<<LOC_API_ADAPTER_BATCHED_POSITION_REPORT)
#define LOC_API_ADAPTER_BIT_GNSS_MEASUREMENT_REPORT (1<<LOC_API_ADAPTER_GNSS_MEASUREMENT_REPORT)
#define LOC_API_ADAPTER_BIT_GNSS_SV_POLYNOMIAL_REPORT (1<<LOC_API_ADAPTER_GNSS_SV_POLYNOMIAL_REPORT)
#define LOC_API_ADAPTER_BIT_GDT_UPLOAD_BEGIN_REQ (1<<LOC_API_ADAPTER_GDT_UPLOAD_BEGIN_REQ)
#define LOC_API_ADAPTER_BIT_GDT_UPLOAD_END_REQ (1<<LOC_API_ADAPTER_GDT_UPLOAD_END_REQ)
#define LOC_API_ADAPTER_BIT_GNSS_MEASUREMENT (1<<LOC_API_ADAPTER_GNSS_MEASUREMENT)
typedef unsigned int LOC_API_ADAPTER_EVENT_MASK_T;

6
loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/LocApiRpc.cpp
View file

@ -715,12 +715,10 @@ void LocApiRpc::reportPosition(const rpc_loc_parsed_position_s_type *location_re
}
// Speed
if ((location_report_ptr->valid_mask & RPC_LOC_POS_VALID_SPEED_HORIZONTAL) &&
(location_report_ptr->valid_mask & RPC_LOC_POS_VALID_SPEED_VERTICAL))
if (location_report_ptr->valid_mask & RPC_LOC_POS_VALID_SPEED_HORIZONTAL)
{
location.gpsLocation.flags |= GPS_LOCATION_HAS_SPEED;
location.gpsLocation.speed = sqrt(location_report_ptr->speed_horizontal * location_report_ptr->speed_horizontal +
location_report_ptr->speed_vertical * location_report_ptr->speed_vertical);
location.gpsLocation.speed = location_report_ptr->speed_horizontal;
}
// Heading

33
loc_api/libloc_api_50001/LocEngAdapter.cpp
View file

@ -408,3 +408,36 @@ enum loc_api_adapter_err LocEngAdapter::setXtraVersionCheck(int check)
EXIT_LOG(%d, ret);
return ret;
}
void LocEngAdapter::reportGpsMeasurementData(GpsData &gpsMeasurementData)
{
sendMsg(new LocEngReportGpsMeasurement(mOwner,
gpsMeasurementData));
}
/*
Update Registration Mask
*/
void LocEngAdapter::updateRegistrationMask(LOC_API_ADAPTER_EVENT_MASK_T event,
loc_registration_mask_status isEnabled)
{
LOC_LOGD("entering %s", __func__);
int result = LOC_API_ADAPTER_ERR_FAILURE;
result = mLocApi->updateRegistrationMask(event, isEnabled);
if (result == LOC_API_ADAPTER_ERR_SUCCESS) {
LOC_LOGD("%s] update registration mask succeed.", __func__);
} else {
LOC_LOGE("%s] update registration mask failed.", __func__);
}
}
/*
Set Gnss Constellation Config
*/
bool LocEngAdapter::gnssConstellationConfig()
{
LOC_LOGD("entering %s", __func__);
bool result = false;
result = mLocApi->gnssConstellationConfig();
return result;
}

11
loc_api/libloc_api_50001/LocEngAdapter.h
View file

@ -286,6 +286,7 @@ public:
virtual bool requestSuplES(int connHandle);
virtual bool reportDataCallOpened();
virtual bool reportDataCallClosed();
virtual void reportGpsMeasurementData(GpsData &gpsMeasurementData);
inline const LocPosMode& getPositionMode() const
{return mFixCriteria;}
@ -336,6 +337,16 @@ public:
return mLocApi->getGpsLock();
}
/*
Update Registration Mask
*/
void updateRegistrationMask(LOC_API_ADAPTER_EVENT_MASK_T event,
loc_registration_mask_status isEnabled);
/*
Set Gnss Constellation Config
*/
bool gnssConstellationConfig();
};
#endif //LOC_API_ENG_ADAPTER_H

65
loc_api/libloc_api_50001/loc.cpp
View file

@ -150,6 +150,17 @@ typedef struct {
static s_loc_mdm_info loc_mdm_info;
static void loc_pm_event_notifier(void *client_data, enum pm_event event);
#endif /*MODEM_POWER_VOTE*/
// For shutting down MDM in fusion devices
static int mdm_fd = -1;
static int loc_gps_measurement_init(GpsMeasurementCallbacks* callbacks);
static void loc_gps_measurement_close();
static const GpsMeasurementInterface sLocEngGpsMeasurementInterface =
{
sizeof(GpsMeasurementInterface),
loc_gps_measurement_init,
loc_gps_measurement_close
};
static void loc_agps_ril_init( AGpsRilCallbacks* callbacks );
static void loc_agps_ril_set_ref_location(const AGpsRefLocation *agps_reflocation, size_t sz_struct);
@ -786,6 +797,10 @@ const void* loc_get_extension(const char* name)
{
ret_val = &sLocEngConfigInterface;
}
else if (strcmp(name, GPS_MEASUREMENT_INTERFACE) == 0)
{
ret_val = &sLocEngGpsMeasurementInterface;
}
else
{
LOC_LOGE ("get_extension: Invalid interface passed in\n");
@ -993,6 +1008,56 @@ static int loc_xtra_inject_data(char* data, int length)
return ret_val;
}
/*===========================================================================
FUNCTION loc_gps_measurement_init
DESCRIPTION
This function initializes the gps measurement interface
DEPENDENCIES
NONE
RETURN VALUE
None
SIDE EFFECTS
N/A
===========================================================================*/
static int loc_gps_measurement_init(GpsMeasurementCallbacks* callbacks)
{
ENTRY_LOG();
int ret_val = loc_eng_gps_measurement_init(loc_afw_data,
callbacks);
EXIT_LOG(%d, ret_val);
return ret_val;
}
/*===========================================================================
FUNCTION loc_gps_measurement_close
DESCRIPTION
This function closes the gps measurement interface
DEPENDENCIES
NONE
RETURN VALUE
None
SIDE EFFECTS
N/A
===========================================================================*/
static void loc_gps_measurement_close()
{
ENTRY_LOG();
loc_eng_gps_measurement_close(loc_afw_data);
EXIT_LOG(%s, VOID_RET);
}
/*===========================================================================
FUNCTION loc_ni_init

301
loc_api/libloc_api_50001/loc_eng.cpp
View file

@ -106,6 +106,10 @@ static loc_param_s_type gps_conf_table[] =
{"ACCURACY_THRES", &gps_conf.ACCURACY_THRES, NULL, 'n'},
{"NMEA_PROVIDER", &gps_conf.NMEA_PROVIDER, NULL, 'n'},
{"CAPABILITIES", &gps_conf.CAPABILITIES, NULL, 'n'},
{"XTRA_VERSION_CHECK", &gps_conf.XTRA_VERSION_CHECK, NULL, 'n'},
{"XTRA_SERVER_1", &gps_conf.XTRA_SERVER_1, NULL, 's'},
{"XTRA_SERVER_2", &gps_conf.XTRA_SERVER_2, NULL, 's'},
{"XTRA_SERVER_3", &gps_conf.XTRA_SERVER_3, NULL, 's'},
{"USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL", &gps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL, NULL, 'n'},
};
@ -127,12 +131,7 @@ static loc_param_s_type sap_conf_table[] =
{"SENSOR_CONTROL_MODE", &sap_conf.SENSOR_CONTROL_MODE, NULL, 'n'},
{"SENSOR_USAGE", &sap_conf.SENSOR_USAGE, NULL, 'n'},
{"SENSOR_ALGORITHM_CONFIG_MASK", &sap_conf.SENSOR_ALGORITHM_CONFIG_MASK, NULL, 'n'},
{"SENSOR_PROVIDER", &sap_conf.SENSOR_PROVIDER, NULL, 'n'},
{"XTRA_VERSION_CHECK", &gps_conf.XTRA_VERSION_CHECK, NULL, 'n'},
{"XTRA_SERVER_1", &gps_conf.XTRA_SERVER_1, NULL, 's'},
{"XTRA_SERVER_2", &gps_conf.XTRA_SERVER_2, NULL, 's'},
{"XTRA_SERVER_3", &gps_conf.XTRA_SERVER_3, NULL, 's'},
{"AGPS_CERT_WRITABLE_MASK", &gps_conf.AGPS_CERT_WRITABLE_MASK, NULL, 'n'}
{"SENSOR_PROVIDER", &sap_conf.SENSOR_PROVIDER, NULL, 'n'}
};
static void loc_default_parameters(void)
@ -839,16 +838,7 @@ void LocEngReportPosition::proc() const {
}
}
void LocEngReportPosition::locallog() const {
LOC_LOGV("flags: %d\n source: %d\n latitude: %f\n longitude: %f\n "
"altitude: %f\n speed: %f\n bearing: %f\n accuracy: %f\n "
"timestamp: %lld\n rawDataSize: %d\n rawData: %p\n Session"
" status: %d\n Technology mask: %u",
mLocation.gpsLocation.flags, mLocation.position_source,
mLocation.gpsLocation.latitude, mLocation.gpsLocation.longitude,
mLocation.gpsLocation.altitude, mLocation.gpsLocation.speed,
mLocation.gpsLocation.bearing, mLocation.gpsLocation.accuracy,
mLocation.gpsLocation.timestamp, mLocation.rawDataSize,
mLocation.rawData, mStatus, mTechMask);
LOC_LOGV("LocEngReportPosition");
}
void LocEngReportPosition::log() const {
locallog();
@ -889,19 +879,7 @@ void LocEngReportSv::proc() const {
}
}
void LocEngReportSv::locallog() const {
LOC_LOGV("num sv: %d\n ephemeris mask: %dxn almanac mask: %x\n "
"used in fix mask: %x\n sv: prn snr "
"elevation azimuth",
mSvStatus.num_svs, mSvStatus.ephemeris_mask,
mSvStatus.almanac_mask, mSvStatus.used_in_fix_mask);
for (int i = 0; i < mSvStatus.num_svs && i < GPS_MAX_SVS; i++) {
LOC_LOGV(" %d: %d %f %f %f\n ",
i,
mSvStatus.sv_list[i].prn,
mSvStatus.sv_list[i].snr,
mSvStatus.sv_list[i].elevation,
mSvStatus.sv_list[i].azimuth);
}
LOC_LOGV("%s:%d] LocEngReportSv",__func__, __LINE__);
}
inline void LocEngReportSv::log() const {
locallog();
@ -1394,6 +1372,33 @@ struct LocEngEnableData : public LocMsg {
// case LOC_ENG_MSG_INJECT_XTRA_DATA:
// loc_eng_xtra.cpp
// case LOC_ENG_MSG_SET_CAPABILITIES:
struct LocEngSetCapabilities : public LocMsg {
loc_eng_data_s_type* mLocEng;
inline LocEngSetCapabilities(loc_eng_data_s_type* locEng) :
LocMsg(), mLocEng(locEng)
{
locallog();
}
inline virtual void proc() const {
if (NULL != mLocEng->set_capabilities_cb) {
LOC_LOGV("calling set_capabilities_cb 0x%x",
gps_conf.CAPABILITIES);
mLocEng->set_capabilities_cb(gps_conf.CAPABILITIES);
} else {
LOC_LOGV("set_capabilities_cb is NULL.\n");
}
}
inline void locallog() const
{
LOC_LOGV("LocEngSetCapabilities");
}
inline virtual void log() const
{
locallog();
}
};
// case LOC_ENG_MSG_LOC_INIT:
struct LocEngInit : public LocMsg {
loc_eng_data_s_type* mLocEng;
@ -1404,6 +1409,8 @@ struct LocEngInit : public LocMsg {
}
inline virtual void proc() const {
loc_eng_reinit(*mLocEng);
// set the capabilities
mLocEng->adapter->sendMsg(new LocEngSetCapabilities(mLocEng));
}
inline void locallog() const
{
@ -1593,6 +1600,99 @@ struct LocEngInstallAGpsCert : public LocMsg {
}
};
struct LocEngUpdateRegistrationMask : public LocMsg {
loc_eng_data_s_type* mLocEng;
LOC_API_ADAPTER_EVENT_MASK_T mMask;
loc_registration_mask_status mIsEnabled;
inline LocEngUpdateRegistrationMask(loc_eng_data_s_type* locEng,
LOC_API_ADAPTER_EVENT_MASK_T mask,
loc_registration_mask_status isEnabled) :
LocMsg(), mLocEng(locEng), mMask(mask), mIsEnabled(isEnabled) {
locallog();
}
inline virtual void proc() const {
loc_eng_data_s_type *locEng = (loc_eng_data_s_type *)mLocEng;
locEng->adapter->updateRegistrationMask(mMask,
mIsEnabled);
}
void locallog() const {
LOC_LOGV("LocEngUpdateRegistrationMask\n");
}
virtual void log() const {
locallog();
}
};
struct LocEngGnssConstellationConfig : public LocMsg {
LocEngAdapter* mAdapter;
inline LocEngGnssConstellationConfig(LocEngAdapter* adapter) :
LocMsg(), mAdapter(adapter) {
locallog();
}
inline virtual void proc() const {
if (mAdapter->gnssConstellationConfig()) {
LOC_LOGV("Modem supports GNSS measurements\n");
gps_conf.CAPABILITIES |= GPS_CAPABILITY_MEASUREMENTS;
} else {
LOC_LOGV("Modem does not support GNSS measurements\n");
}
}
void locallog() const {
LOC_LOGV("LocEngGnssConstellationConfig\n");
}
virtual void log() const {
locallog();
}
};
// case LOC_ENG_MSG_REPORT_GNSS_MEASUREMENT:
LocEngReportGpsMeasurement::LocEngReportGpsMeasurement(void* locEng,
GpsData &gpsData) :
LocMsg(), mLocEng(locEng), mGpsData(gpsData)
{
locallog();
}
void LocEngReportGpsMeasurement::proc() const {
loc_eng_data_s_type* locEng = (loc_eng_data_s_type*) mLocEng;
if (locEng->mute_session_state != LOC_MUTE_SESS_IN_SESSION)
{
if (locEng->gps_measurement_cb != NULL) {
locEng->gps_measurement_cb((GpsData*)&(mGpsData));
}
}
}
void LocEngReportGpsMeasurement::locallog() const {
IF_LOC_LOGV {
LOC_LOGV("%s:%d]: Received in GPS HAL."
"GNSS Measurements count: %d \n",
__func__, __LINE__, mGpsData.measurement_count);
for (int i =0; i< mGpsData.measurement_count && i < GPS_MAX_SVS; i++) {
LOC_LOGV(" GNSS measurement data in GPS HAL: \n"
" GPS_HAL => Measurement ID | prn | time_offset_ns | state |"
" received_gps_tow_ns| c_n0_dbhz | pseudorange_rate_mps |"
" pseudorange_rate_uncertainty_mps |"
" accumulated_delta_range_state | flags \n"
" GPS_HAL => %d | %d | %f | %d | %lld | %f | %f | %f | %d | %d \n",
i,
mGpsData.measurements[i].prn,
mGpsData.measurements[i].time_offset_ns,
mGpsData.measurements[i].state,
mGpsData.measurements[i].received_gps_tow_ns,
mGpsData.measurements[i].c_n0_dbhz,
mGpsData.measurements[i].pseudorange_rate_mps,
mGpsData.measurements[i].pseudorange_rate_uncertainty_mps,
mGpsData.measurements[i].accumulated_delta_range_state,
mGpsData.measurements[i].flags);
}
LOC_LOGV(" GPS_HAL => Clocks Info: type | time_ns \n"
" GPS_HAL => Clocks Info: %d | %lld", mGpsData.clock.type,
mGpsData.clock.time_ns);
}
}
inline void LocEngReportGpsMeasurement::log() const {
locallog();
}
/*********************************************************************
* Initialization checking macros
*********************************************************************/
@ -1660,10 +1760,6 @@ int loc_eng_init(loc_eng_data_s_type &loc_eng_data, LocCallbacks* callbacks,
memset(&loc_eng_data, 0, sizeof (loc_eng_data));
if (NULL != callbacks->set_capabilities_cb) {
callbacks->set_capabilities_cb(gps_conf.CAPABILITIES);
}
// Save callbacks
loc_eng_data.location_cb = callbacks->location_cb;
loc_eng_data.sv_status_cb = callbacks->sv_status_cb;
@ -1712,6 +1808,7 @@ static int loc_eng_reinit(loc_eng_data_s_type &loc_eng_data)
int ret_val = LOC_API_ADAPTER_ERR_SUCCESS;
LocEngAdapter* adapter = loc_eng_data.adapter;
adapter->sendMsg(new LocEngGnssConstellationConfig(adapter));
adapter->sendMsg(new LocEngSuplVer(adapter, gps_conf.SUPL_VER));
adapter->sendMsg(new LocEngLppConfig(adapter, gps_conf.LPP_PROFILE));
adapter->sendMsg(new LocEngSensorControlConfig(adapter, sap_conf.SENSOR_USAGE,
@ -2526,29 +2623,29 @@ int loc_eng_set_server_proxy(loc_eng_data_s_type &loc_eng_data,
ENTRY_LOG_CALLFLOW();
int ret_val = 0;
LOC_LOGV("save the address, type: %d, hostname: %s, port: %d",
(int) type, hostname, port);
switch (type)
{
case LOC_AGPS_SUPL_SERVER:
strlcpy(loc_eng_data.supl_host_buf, hostname,
sizeof(loc_eng_data.supl_host_buf));
loc_eng_data.supl_port_buf = port;
loc_eng_data.supl_host_set = 1;
break;
case LOC_AGPS_CDMA_PDE_SERVER:
strlcpy(loc_eng_data.c2k_host_buf, hostname,
sizeof(loc_eng_data.c2k_host_buf));
loc_eng_data.c2k_port_buf = port;
loc_eng_data.c2k_host_set = 1;
break;
default:
LOC_LOGE("loc_eng_set_server_proxy, unknown server type = %d", (int) type);
}
if (NULL != loc_eng_data.adapter)
{
ret_val = loc_eng_set_server(loc_eng_data, type, hostname, port);
} else {
LOC_LOGW("set_server called before init. save the address, type: %d, hostname: %s, port: %d",
(int) type, hostname, port);
switch (type)
{
case LOC_AGPS_SUPL_SERVER:
strlcpy(loc_eng_data.supl_host_buf, hostname,
sizeof(loc_eng_data.supl_host_buf));
loc_eng_data.supl_port_buf = port;
loc_eng_data.supl_host_set = 1;
break;
case LOC_AGPS_CDMA_PDE_SERVER:
strlcpy(loc_eng_data.c2k_host_buf, hostname,
sizeof(loc_eng_data.c2k_host_buf));
loc_eng_data.c2k_port_buf = port;
loc_eng_data.c2k_host_set = 1;
break;
default:
LOC_LOGE("loc_eng_set_server_proxy, unknown server type = %d", (int) type);
}
}
EXIT_LOG(%d, ret_val);
@ -2651,33 +2748,32 @@ void loc_eng_configuration_update (loc_eng_data_s_type &loc_eng_data,
ENTRY_LOG_CALLFLOW();
if (config_data && length > 0) {
loc_gps_cfg_s_type gps_conf_old = gps_conf;
loc_gps_cfg_s_type gps_conf_tmp = gps_conf;
UTIL_UPDATE_CONF(config_data, length, gps_conf_table);
LocEngAdapter* adapter = loc_eng_data.adapter;
// it is possible that HAL is not init'ed at this time
if (adapter) {
if (gps_conf_old.SUPL_VER != gps_conf.SUPL_VER) {
if (gps_conf_tmp.SUPL_VER != gps_conf.SUPL_VER) {
adapter->sendMsg(new LocEngSuplVer(adapter, gps_conf.SUPL_VER));
}
if (gps_conf_old.LPP_PROFILE != gps_conf.LPP_PROFILE) {
if (gps_conf_tmp.LPP_PROFILE != gps_conf.LPP_PROFILE) {
adapter->sendMsg(new LocEngLppConfig(adapter, gps_conf.LPP_PROFILE));
}
if (gps_conf_old.A_GLONASS_POS_PROTOCOL_SELECT != gps_conf.A_GLONASS_POS_PROTOCOL_SELECT) {
if (gps_conf_tmp.A_GLONASS_POS_PROTOCOL_SELECT != gps_conf.A_GLONASS_POS_PROTOCOL_SELECT) {
adapter->sendMsg(new LocEngAGlonassProtocol(adapter,
gps_conf.A_GLONASS_POS_PROTOCOL_SELECT));
}
if (gps_conf_old.SUPL_MODE != gps_conf.SUPL_MODE) {
if (gps_conf_tmp.SUPL_MODE != gps_conf.SUPL_MODE) {
adapter->sendMsg(new LocEngSuplMode(adapter->getUlpProxy()));
}
}
gps_conf_old.SUPL_VER = gps_conf.SUPL_VER;
gps_conf_old.LPP_PROFILE = gps_conf.LPP_PROFILE;
gps_conf_old.A_GLONASS_POS_PROTOCOL_SELECT = gps_conf.A_GLONASS_POS_PROTOCOL_SELECT;
gps_conf_old.SUPL_MODE = gps_conf.SUPL_MODE;
gps_conf = gps_conf_old;
gps_conf_tmp.SUPL_VER = gps_conf.SUPL_VER;
gps_conf_tmp.LPP_PROFILE = gps_conf.LPP_PROFILE;
gps_conf_tmp.A_GLONASS_POS_PROTOCOL_SELECT = gps_conf.A_GLONASS_POS_PROTOCOL_SELECT;
gps_conf_tmp.GPS_LOCK = gps_conf.GPS_LOCK;
gps_conf = gps_conf_tmp;
}
EXIT_LOG(%s, VOID_RET);
@ -2887,3 +2983,80 @@ void loc_eng_handle_shutdown(loc_eng_data_s_type &locEng)
locEng.shutdown_cb();
EXIT_LOG(%d, 0);
}
/*===========================================================================
FUNCTION loc_eng_gps_measurement_init
DESCRIPTION
Initialize gps measurement module.
DEPENDENCIES
N/A
RETURN VALUE
0: success
SIDE EFFECTS
N/A
===========================================================================*/
int loc_eng_gps_measurement_init(loc_eng_data_s_type &loc_eng_data,
GpsMeasurementCallbacks* callbacks)
{
ENTRY_LOG_CALLFLOW();
STATE_CHECK((NULL == loc_eng_data.gps_measurement_cb),
"gps measurement already initialized",
return GPS_MEASUREMENT_ERROR_ALREADY_INIT);
STATE_CHECK((callbacks != NULL),
"callbacks can not be NULL",
return GPS_MEASUREMENT_ERROR_GENERIC);
STATE_CHECK(loc_eng_data.adapter,
"GpsInterface must be initialized first",
return GPS_MEASUREMENT_ERROR_GENERIC);
// updated the mask
LOC_API_ADAPTER_EVENT_MASK_T event = LOC_API_ADAPTER_BIT_GNSS_MEASUREMENT;
loc_eng_data.adapter->sendMsg(new LocEngUpdateRegistrationMask(
&loc_eng_data,
event,
LOC_REGISTRATION_MASK_ENABLED));
// set up the callback
loc_eng_data.gps_measurement_cb = callbacks->measurement_callback;
LOC_LOGD ("%s, event masks updated successfully", __func__);
return GPS_MEASUREMENT_OPERATION_SUCCESS;
}
/*===========================================================================
FUNCTION loc_eng_gps_measurement_close
DESCRIPTION
Close gps measurement module.
DEPENDENCIES
N/A
RETURN VALUE
N/A
SIDE EFFECTS
N/A
===========================================================================*/
void loc_eng_gps_measurement_close(loc_eng_data_s_type &loc_eng_data)
{
ENTRY_LOG_CALLFLOW();
INIT_CHECK(loc_eng_data.adapter, return);
// updated the mask
LOC_API_ADAPTER_EVENT_MASK_T event = LOC_API_ADAPTER_BIT_GNSS_MEASUREMENT;
loc_eng_data.adapter->sendMsg(new LocEngUpdateRegistrationMask(
&loc_eng_data,
event,
LOC_REGISTRATION_MASK_DISABLED));
// set up the callback
loc_eng_data.gps_measurement_cb = NULL;
EXIT_LOG(%d, 0);
}

4
loc_api/libloc_api_50001/loc_eng.h
View file

@ -94,6 +94,7 @@ typedef struct loc_eng_data_s
gps_acquire_wakelock acquire_wakelock_cb;
gps_release_wakelock release_wakelock_cb;
gps_request_utc_time request_utc_time_cb;
gps_measurement_callback gps_measurement_cb;
boolean intermediateFix;
AGpsStatusValue agps_status;
loc_eng_xtra_data_s_type xtra_module_data;
@ -259,6 +260,9 @@ extern void loc_eng_ni_reset_on_engine_restart(loc_eng_data_s_type &loc_eng_data
void loc_eng_configuration_update (loc_eng_data_s_type &loc_eng_data,
const char* config_data, int32_t length);
int loc_eng_gps_measurement_init(loc_eng_data_s_type &loc_eng_data,
GpsMeasurementCallbacks* callbacks);
void loc_eng_gps_measurement_close(loc_eng_data_s_type &loc_eng_data);
#ifdef __cplusplus
}

10
loc_api/libloc_api_50001/loc_eng_msg.h
View file

@ -289,6 +289,16 @@ struct LocEngGetZpp : public LocMsg {
void send() const;
};
struct LocEngReportGpsMeasurement : public LocMsg {
void* mLocEng;
const GpsData mGpsData;
LocEngReportGpsMeasurement(void* locEng,
GpsData &gpsData);
virtual void proc() const;
void locallog() const;
virtual void log() const;
};
struct LocEngShutdown : public LocMsg {
LocEngAdapter* mAdapter;
LocEngShutdown(LocEngAdapter* adapter);