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

Enable/disable PDN for emergency SUPL at runtime

Browse source 
This feature makes AGPS enable/disable PDN for
emergency SUPL according to new setting in
gps.conf when SIM is replaced at runtime

Change-Id: Idbc086b938ded02ba702ea080ded69e9b4761e46
CRs-fixed: 1026702
This commit is contained in:
Kevin Tang 2016-06-14 16:23:42 -07:00
parent 62743a2219
commit 5ceb69dc42
1 changed files with 82 additions and 55 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

137
loc_api/libloc_api_50001/loc_eng.cpp
View file

@ -196,6 +196,7 @@ static int loc_eng_get_zpp_handler(loc_eng_data_s_type &loc_eng_data);
static void deleteAidingData(loc_eng_data_s_type &logEng); static void deleteAidingData(loc_eng_data_s_type &logEng);
static AgpsStateMachine* static AgpsStateMachine*
getAgpsStateMachine(loc_eng_data_s_type& logEng, AGpsExtType agpsType); getAgpsStateMachine(loc_eng_data_s_type& logEng, AGpsExtType agpsType);
static void createAgnssNifs(loc_eng_data_s_type& locEng);
static int dataCallCb(void *cb_data); static int dataCallCb(void *cb_data);
static void update_aiding_data_for_deletion(loc_eng_data_s_type& loc_eng_data) { static void update_aiding_data_for_deletion(loc_eng_data_s_type& loc_eng_data) {
if (loc_eng_data.engine_status != GPS_STATUS_ENGINE_ON && if (loc_eng_data.engine_status != GPS_STATUS_ENGINE_ON &&
@ -1102,7 +1103,7 @@ LocEngRequestSuplEs::LocEngRequestSuplEs(void* locEng, int id) :
} }
void LocEngRequestSuplEs::proc() const { void LocEngRequestSuplEs::proc() const {
loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng; loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
if (locEng->ds_nif) { if (locEng->ds_nif && gps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL) {
AgpsStateMachine* sm = locEng->ds_nif; AgpsStateMachine* sm = locEng->ds_nif;
DSSubscriber s(sm, mID); DSSubscriber s(sm, mID);
sm->subscribeRsrc((Subscriber*)&s); sm->subscribeRsrc((Subscriber*)&s);
@ -1444,16 +1445,18 @@ struct LocEngInit : public LocMsg {
// case LOC_ENG_MSG_ATL_OPEN_SUCCESS: // case LOC_ENG_MSG_ATL_OPEN_SUCCESS:
struct LocEngAtlOpenSuccess : public LocMsg { struct LocEngAtlOpenSuccess : public LocMsg {
AgpsStateMachine* mStateMachine; loc_eng_data_s_type* mLocEng;
const AGpsExtType mAgpsType;
const int mLen; const int mLen;
char* mAPN; char* mAPN;
const AGpsBearerType mBearerType; const AGpsBearerType mBearerType;
inline LocEngAtlOpenSuccess(AgpsStateMachine* statemachine, inline LocEngAtlOpenSuccess(loc_eng_data_s_type* locEng,
const AGpsExtType agpsType,
const char* name, const char* name,
int len, int len,
AGpsBearerType btype) : AGpsBearerType btype) :
LocMsg(), LocMsg(),
mStateMachine(statemachine), mLen(len), mLocEng(locEng), mAgpsType(agpsType), mLen(len),
mAPN(new char[len+1]), mBearerType(btype) mAPN(new char[len+1]), mBearerType(btype)
{ {
memcpy((void*)mAPN, (void*)name, len); memcpy((void*)mAPN, (void*)name, len);
@ -1465,14 +1468,15 @@ struct LocEngAtlOpenSuccess : public LocMsg {
delete[] mAPN; delete[] mAPN;
} }
inline virtual void proc() const { inline virtual void proc() const {
mStateMachine->setBearer(mBearerType); AgpsStateMachine* sm = getAgpsStateMachine(*mLocEng, mAgpsType);
mStateMachine->setAPN(mAPN, mLen); sm->setBearer(mBearerType);
mStateMachine->onRsrcEvent(RSRC_GRANTED); sm->setAPN(mAPN, mLen);
sm->onRsrcEvent(RSRC_GRANTED);
} }
inline void locallog() const { inline void locallog() const {
LOC_LOGV("LocEngAtlOpenSuccess agps type: %s\n apn: %s\n" LOC_LOGV("LocEngAtlOpenSuccess agps type: %s\n apn: %s\n"
" bearer type: %s", " bearer type: %s",
loc_get_agps_type_name(mStateMachine->getType()), loc_get_agps_type_name(mAgpsType),
mAPN, mAPN,
loc_get_agps_bear_name(mBearerType)); loc_get_agps_bear_name(mBearerType));
} }
@ -1483,13 +1487,16 @@ struct LocEngAtlOpenSuccess : public LocMsg {
// case LOC_ENG_MSG_ATL_CLOSED: // case LOC_ENG_MSG_ATL_CLOSED:
struct LocEngAtlClosed : public LocMsg { struct LocEngAtlClosed : public LocMsg {
AgpsStateMachine* mStateMachine; loc_eng_data_s_type* mLocEng;
inline LocEngAtlClosed(AgpsStateMachine* statemachine) : const AGpsExtType mAgpsType;
LocMsg(), mStateMachine(statemachine) { inline LocEngAtlClosed(loc_eng_data_s_type* locEng,
const AGpsExtType agpsType) :
LocMsg(), mLocEng(locEng), mAgpsType(agpsType) {
locallog(); locallog();
} }
inline virtual void proc() const { inline virtual void proc() const {
mStateMachine->onRsrcEvent(RSRC_RELEASED); AgpsStateMachine* sm = getAgpsStateMachine(*mLocEng, mAgpsType);
sm->onRsrcEvent(RSRC_RELEASED);
} }
inline void locallog() const { inline void locallog() const {
LOC_LOGV("LocEngAtlClosed"); LOC_LOGV("LocEngAtlClosed");
@ -1501,13 +1508,16 @@ struct LocEngAtlClosed : public LocMsg {
// case LOC_ENG_MSG_ATL_OPEN_FAILED: // case LOC_ENG_MSG_ATL_OPEN_FAILED:
struct LocEngAtlOpenFailed : public LocMsg { struct LocEngAtlOpenFailed : public LocMsg {
AgpsStateMachine* mStateMachine; loc_eng_data_s_type* mLocEng;
inline LocEngAtlOpenFailed(AgpsStateMachine* statemachine) : const AGpsExtType mAgpsType;
LocMsg(), mStateMachine(statemachine) { inline LocEngAtlOpenFailed(loc_eng_data_s_type* locEng,
const AGpsExtType agpsType) :
LocMsg(), mLocEng(locEng), mAgpsType(agpsType) {
locallog(); locallog();
} }
inline virtual void proc() const { inline virtual void proc() const {
mStateMachine->onRsrcEvent(RSRC_DENIED); AgpsStateMachine* sm = getAgpsStateMachine(*mLocEng, mAgpsType);
sm->onRsrcEvent(RSRC_DENIED);
} }
inline void locallog() const { inline void locallog() const {
LOC_LOGV("LocEngAtlOpenFailed"); LOC_LOGV("LocEngAtlOpenFailed");
@ -1549,22 +1559,17 @@ inline void LocEngUp::log() const {
locallog(); locallog();
} }
struct LocEngDataClientInit : public LocMsg { struct LocEngAgnssNifInit : public LocMsg {
loc_eng_data_s_type* mLocEng; loc_eng_data_s_type* mLocEng;
inline LocEngDataClientInit(loc_eng_data_s_type* locEng) : inline LocEngAgnssNifInit(loc_eng_data_s_type* locEng) :
LocMsg(), mLocEng(locEng) { LocMsg(), mLocEng(locEng) {
locallog(); locallog();
} }
virtual void proc() const { virtual void proc() const {
loc_eng_data_s_type *locEng = (loc_eng_data_s_type *)mLocEng; createAgnssNifs(*mLocEng);
if(!locEng->adapter->initDataServiceClient()) {
locEng->ds_nif = new DSStateMachine(servicerTypeExt,
(void *)dataCallCb,
locEng->adapter);
}
} }
void locallog() const { void locallog() const {
LOC_LOGV("LocEngDataClientInit\n"); LOC_LOGV("LocEngAgnssNifInit\n");
} }
virtual void log() const { virtual void log() const {
locallog(); locallog();
@ -2338,31 +2343,14 @@ void loc_eng_agps_init(loc_eng_data_s_type &loc_eng_data, AGpsExtCallbacks* call
EXIT_LOG(%s, VOID_RET); EXIT_LOG(%s, VOID_RET);
return; return;
} }
bool agpsCapable = ((gps_conf.CAPABILITIES & GPS_CAPABILITY_MSA) ||
(gps_conf.CAPABILITIES & GPS_CAPABILITY_MSB));
LocEngAdapter* adapter = loc_eng_data.adapter; LocEngAdapter* adapter = loc_eng_data.adapter;
loc_eng_data.agps_status_cb = callbacks->status_cb; loc_eng_data.agps_status_cb = callbacks->status_cb;
loc_eng_data.internet_nif = new AgpsStateMachine(servicerTypeAgps, if (agpsCapable && NULL != adapter) {
(void *)loc_eng_data.agps_status_cb,
AGPS_TYPE_WWAN_ANY,
false);
loc_eng_data.wifi_nif = new AgpsStateMachine(servicerTypeAgps,
(void *)loc_eng_data.agps_status_cb,
AGPS_TYPE_WIFI,
true);
if ((gps_conf.CAPABILITIES & GPS_CAPABILITY_MSA) ||
(gps_conf.CAPABILITIES & GPS_CAPABILITY_MSB)) {
loc_eng_data.agnss_nif = new AgpsStateMachine(servicerTypeAgps,
(void *)loc_eng_data.agps_status_cb,
AGPS_TYPE_SUPL,
false);
if (adapter->mSupportsAgpsRequests) { if (adapter->mSupportsAgpsRequests) {
if(gps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL) { adapter->sendMsg(new LocEngAgnssNifInit(&loc_eng_data));
loc_eng_data.adapter->sendMsg(new LocEngDataClientInit(&loc_eng_data));
}
loc_eng_dmn_conn_loc_api_server_launch(callbacks->create_thread_cb,
NULL, NULL, &loc_eng_data);
} }
loc_eng_agps_reinit(loc_eng_data); loc_eng_agps_reinit(loc_eng_data);
} }
@ -2378,6 +2366,35 @@ static void deleteAidingData(loc_eng_data_s_type &logEng) {
} }
} }
// must be called under msg handler context
static void createAgnssNifs(loc_eng_data_s_type& locEng) {
bool agpsCapable = ((gps_conf.CAPABILITIES & GPS_CAPABILITY_MSA) ||
(gps_conf.CAPABILITIES & GPS_CAPABILITY_MSB));
LocEngAdapter* adapter = locEng.adapter;
if (agpsCapable && NULL != adapter && adapter->mSupportsAgpsRequests) {
if (NULL == locEng.internet_nif) {
locEng.internet_nif= new AgpsStateMachine(servicerTypeAgps,
(void *)locEng.agps_status_cb,
AGPS_TYPE_WWAN_ANY,
false);
}
if (NULL == locEng.agnss_nif) {
locEng.agnss_nif = new AgpsStateMachine(servicerTypeAgps,
(void *)locEng.agps_status_cb,
AGPS_TYPE_SUPL,
false);
}
if (NULL == locEng.ds_nif &&
gps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL &&
0 == adapter->initDataServiceClient()) {
locEng.ds_nif = new DSStateMachine(servicerTypeExt,
(void *)dataCallCb,
locEng.adapter);
}
}
}
// must be called under msg handler context
static AgpsStateMachine* static AgpsStateMachine*
getAgpsStateMachine(loc_eng_data_s_type &locEng, AGpsExtType agpsType) { getAgpsStateMachine(loc_eng_data_s_type &locEng, AGpsExtType agpsType) {
AgpsStateMachine* stateMachine; AgpsStateMachine* stateMachine;
@ -2392,9 +2409,14 @@ getAgpsStateMachine(loc_eng_data_s_type &locEng, AGpsExtType agpsType) {
break; break;
} }
case AGPS_TYPE_SUPL_ES: { case AGPS_TYPE_SUPL_ES: {
locEng.ds_nif ? if (gps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL) {
stateMachine = locEng.ds_nif: if (NULL == locEng.ds_nif) {
createAgnssNifs(locEng);
}
stateMachine = locEng.ds_nif;
} else {
stateMachine = locEng.agnss_nif; stateMachine = locEng.agnss_nif;
}
break; break;
} }
default: default:
@ -2436,10 +2458,9 @@ int loc_eng_agps_open(loc_eng_data_s_type &loc_eng_data, AGpsExtType agpsType,
LOC_LOGD("loc_eng_agps_open APN name = [%s]", apn); LOC_LOGD("loc_eng_agps_open APN name = [%s]", apn);
int apn_len = smaller_of(strlen (apn), MAX_APN_LEN); int apn_len = smaller_of(strlen (apn), MAX_APN_LEN);
AgpsStateMachine* sm = getAgpsStateMachine(loc_eng_data, agpsType);
loc_eng_data.adapter->sendMsg( loc_eng_data.adapter->sendMsg(
new LocEngAtlOpenSuccess(sm, apn, apn_len, bearerType)); new LocEngAtlOpenSuccess(&loc_eng_data, agpsType,
apn, apn_len, bearerType));
EXIT_LOG(%d, 0); EXIT_LOG(%d, 0);
return 0; return 0;
@ -2468,8 +2489,8 @@ int loc_eng_agps_closed(loc_eng_data_s_type &loc_eng_data, AGpsExtType agpsType)
INIT_CHECK(loc_eng_data.adapter && loc_eng_data.agps_status_cb, INIT_CHECK(loc_eng_data.adapter && loc_eng_data.agps_status_cb,
return -1); return -1);
AgpsStateMachine* sm = getAgpsStateMachine(loc_eng_data, agpsType); loc_eng_data.adapter->sendMsg(new LocEngAtlClosed(&loc_eng_data,
loc_eng_data.adapter->sendMsg(new LocEngAtlClosed(sm)); agpsType));
EXIT_LOG(%d, 0); EXIT_LOG(%d, 0);
return 0; return 0;
@ -2498,8 +2519,8 @@ int loc_eng_agps_open_failed(loc_eng_data_s_type &loc_eng_data, AGpsExtType agps
INIT_CHECK(loc_eng_data.adapter && loc_eng_data.agps_status_cb, INIT_CHECK(loc_eng_data.adapter && loc_eng_data.agps_status_cb,
return -1); return -1);
AgpsStateMachine* sm = getAgpsStateMachine(loc_eng_data, agpsType); loc_eng_data.adapter->sendMsg(new LocEngAtlOpenFailed(&loc_eng_data,
loc_eng_data.adapter->sendMsg(new LocEngAtlOpenFailed(sm)); agpsType));
EXIT_LOG(%d, 0); EXIT_LOG(%d, 0);
return 0; return 0;
@ -2775,6 +2796,10 @@ void loc_eng_configuration_update (loc_eng_data_s_type &loc_eng_data,
if (gps_conf_tmp.SUPL_MODE != gps_conf.SUPL_MODE) { if (gps_conf_tmp.SUPL_MODE != gps_conf.SUPL_MODE) {
adapter->sendMsg(new LocEngSuplMode(adapter->getUlpProxy())); adapter->sendMsg(new LocEngSuplMode(adapter->getUlpProxy()));
} }
// we always update lock mask, this is because if this is dsds device, we would not
// know if modem has switched dds, if so, lock mask may also need to be updated.
// if we have power vote, HAL is on, lock mask 0; else gps_conf.GPS_LOCK.
adapter->setGpsLockMsg(adapter->getPowerVote() ? 0 : gps_conf.GPS_LOCK);
} }
gps_conf_tmp.SUPL_VER = gps_conf.SUPL_VER; gps_conf_tmp.SUPL_VER = gps_conf.SUPL_VER;
@ -2783,6 +2808,8 @@ void loc_eng_configuration_update (loc_eng_data_s_type &loc_eng_data,
gps_conf_tmp.SUPL_MODE = gps_conf.SUPL_MODE; gps_conf_tmp.SUPL_MODE = gps_conf.SUPL_MODE;
gps_conf_tmp.SUPL_ES = gps_conf.SUPL_ES; gps_conf_tmp.SUPL_ES = gps_conf.SUPL_ES;
gps_conf_tmp.GPS_LOCK = gps_conf.GPS_LOCK; gps_conf_tmp.GPS_LOCK = gps_conf.GPS_LOCK;
gps_conf_tmp.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL =
gps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL;
gps_conf = gps_conf_tmp; gps_conf = gps_conf_tmp;
} }