sandy
/
PL286
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1 Commit
1 Branch
0 Tags
18 GiB
Tree: 99da0f2c72
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '99da0f2c72'
${ noResults }
PL286/hardware/qcom/gps/sdm845/gnss/Agps.cpp

965 lines
30 KiB
Raw Blame History

/* Copyright (c) 2012-2017, The Linux Foundation. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of The Linux Foundation, nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#define LOG_TAG "LocSvc_Agps"
#include <Agps.h>
#include <platform_lib_includes.h>
#include <ContextBase.h>
#include <loc_timer.h>
/* --------------------------------------------------------------------
* AGPS State Machine Methods
* -------------------------------------------------------------------*/
void AgpsStateMachine::processAgpsEvent(AgpsEvent event){
LOC_LOGD("processAgpsEvent(): SM %p, Event %d, State %d",
this, event, mState);
switch (event){
case AGPS_EVENT_SUBSCRIBE:
processAgpsEventSubscribe();
break;
case AGPS_EVENT_UNSUBSCRIBE:
processAgpsEventUnsubscribe();
break;
case AGPS_EVENT_GRANTED:
processAgpsEventGranted();
break;
case AGPS_EVENT_RELEASED:
processAgpsEventReleased();
break;
case AGPS_EVENT_DENIED:
processAgpsEventDenied();
break;
default:
LOC_LOGE("Invalid Loc Agps Event");
}
}
void AgpsStateMachine::processAgpsEventSubscribe(){
switch (mState){
case AGPS_STATE_RELEASED:
/* Add subscriber to list
* No notifications until we get RSRC_GRANTED */
addSubscriber(mCurrentSubscriber);
/* Send data request
* The if condition below is added so that if the data call setup
* fails for DS State Machine, we want to retry in released state.
* for Agps State Machine, sendRsrcRequest() will always return
* success. */
if(requestOrReleaseDataConn(true) == 0){
// If data request successful, move to pending state
transitionState(AGPS_STATE_PENDING);
}
break;
case AGPS_STATE_PENDING:
/* Already requested for data connection,
* do nothing until we get RSRC_GRANTED event;
* Just add this subscriber to the list, for notifications */
addSubscriber(mCurrentSubscriber);
break;
case AGPS_STATE_ACQUIRED:
/* We already have the data connection setup,
* Notify current subscriber with GRANTED event,
* And add it to the subscriber list for further notifications. */
notifyEventToSubscriber(AGPS_EVENT_GRANTED, mCurrentSubscriber, false);
addSubscriber(mCurrentSubscriber);
break;
case AGPS_STATE_RELEASING:
addSubscriber(mCurrentSubscriber);
break;
default:
LOC_LOGE("Invalid state: %d", mState);
}
}
void AgpsStateMachine::processAgpsEventUnsubscribe(){
switch (mState){
case AGPS_STATE_RELEASED:
notifyEventToSubscriber(
AGPS_EVENT_UNSUBSCRIBE, mCurrentSubscriber, false);
break;
case AGPS_STATE_PENDING:
case AGPS_STATE_ACQUIRED:
/* If the subscriber wishes to wait for connection close,
* before being removed from list, move to inactive state
* and notify */
if(mCurrentSubscriber->mWaitForCloseComplete){
mCurrentSubscriber->mIsInactive = true;
notifyEventToSubscriber(
AGPS_EVENT_UNSUBSCRIBE, mCurrentSubscriber, false);
}
else{
/* Notify only current subscriber and then delete it from
* subscriberList */
notifyEventToSubscriber(
AGPS_EVENT_UNSUBSCRIBE, mCurrentSubscriber, true);
}
/* If no subscribers in list, release data connection */
if(mSubscriberList.empty()){
transitionState(AGPS_STATE_RELEASED);
requestOrReleaseDataConn(false);
}
/* Some subscribers in list, but all inactive;
* Release data connection */
else if(!anyActiveSubscribers()){
transitionState(AGPS_STATE_RELEASING);
requestOrReleaseDataConn(false);
}
break;
case AGPS_STATE_RELEASING:
/* If the subscriber wishes to wait for connection close,
* before being removed from list, move to inactive state
* and notify */
if(mCurrentSubscriber->mWaitForCloseComplete){
mCurrentSubscriber->mIsInactive = true;
notifyEventToSubscriber(
AGPS_EVENT_UNSUBSCRIBE, mCurrentSubscriber, false);
}
else{
/* Notify only current subscriber and then delete it from
* subscriberList */
notifyEventToSubscriber(
AGPS_EVENT_UNSUBSCRIBE, mCurrentSubscriber, true);
}
/* If no subscribers in list, just move the state.
* Request for releasing data connection should already have been
* sent */
if(mSubscriberList.empty()){
transitionState(AGPS_STATE_RELEASED);
}
break;
default:
LOC_LOGE("Invalid state: %d", mState);
}
}
void AgpsStateMachine::processAgpsEventGranted(){
switch (mState){
case AGPS_STATE_RELEASED:
case AGPS_STATE_ACQUIRED:
case AGPS_STATE_RELEASING:
LOC_LOGE("Unexpected event GRANTED in state %d", mState);
break;
case AGPS_STATE_PENDING:
// Move to acquired state
transitionState(AGPS_STATE_ACQUIRED);
notifyAllSubscribers(
AGPS_EVENT_GRANTED, false,
AGPS_NOTIFICATION_TYPE_FOR_ACTIVE_SUBSCRIBERS);
break;
default:
LOC_LOGE("Invalid state: %d", mState);
}
}
void AgpsStateMachine::processAgpsEventReleased(){
switch (mState){
case AGPS_STATE_RELEASED:
LOC_LOGE("Unexpected event RELEASED in state %d", mState);
break;
case AGPS_STATE_ACQUIRED:
/* Force release received */
LOC_LOGW("Force RELEASED event in ACQUIRED state");
transitionState(AGPS_STATE_RELEASED);
notifyAllSubscribers(
AGPS_EVENT_RELEASED, true,
AGPS_NOTIFICATION_TYPE_FOR_ALL_SUBSCRIBERS);
break;
case AGPS_STATE_RELEASING:
/* Notify all inactive subscribers about the event */
notifyAllSubscribers(
AGPS_EVENT_RELEASED, true,
AGPS_NOTIFICATION_TYPE_FOR_INACTIVE_SUBSCRIBERS);
/* If we have active subscribers now, they must be waiting for
* data conn setup */
if(anyActiveSubscribers()){
transitionState(AGPS_STATE_PENDING);
requestOrReleaseDataConn(true);
}
/* No active subscribers, move to released state */
else{
transitionState(AGPS_STATE_RELEASED);
}
break;
case AGPS_STATE_PENDING:
/* NOOP */
break;
default:
LOC_LOGE("Invalid state: %d", mState);
}
}
void AgpsStateMachine::processAgpsEventDenied(){
switch (mState){
case AGPS_STATE_RELEASED:
LOC_LOGE("Unexpected event DENIED in state %d", mState);
break;
case AGPS_STATE_ACQUIRED:
/* NOOP */
break;
case AGPS_STATE_RELEASING:
/* Notify all inactive subscribers about the event */
notifyAllSubscribers(
AGPS_EVENT_RELEASED, true,
AGPS_NOTIFICATION_TYPE_FOR_INACTIVE_SUBSCRIBERS);
/* If we have active subscribers now, they must be waiting for
* data conn setup */
if(anyActiveSubscribers()){
transitionState(AGPS_STATE_PENDING);
requestOrReleaseDataConn(true);
}
/* No active subscribers, move to released state */
else{
transitionState(AGPS_STATE_RELEASED);
}
break;
case AGPS_STATE_PENDING:
transitionState(AGPS_STATE_RELEASED);
notifyAllSubscribers(
AGPS_EVENT_DENIED, true,
AGPS_NOTIFICATION_TYPE_FOR_ALL_SUBSCRIBERS);
break;
default:
LOC_LOGE("Invalid state: %d", mState);
}
}
/* Request or Release data connection
* bool request :
* true = Request data connection
* false = Release data connection */
int AgpsStateMachine::requestOrReleaseDataConn(bool request){
AgpsFrameworkInterface::AGnssStatusIpV4 nifRequest;
memset(&nifRequest, 0, sizeof(nifRequest));
nifRequest.type = (AgpsFrameworkInterface::AGnssType)mAgpsType;
if(request){
LOC_LOGD("AGPS Data Conn Request");
nifRequest.status = (AgpsFrameworkInterface::AGnssStatusValue)
LOC_GPS_REQUEST_AGPS_DATA_CONN;
}
else{
LOC_LOGD("AGPS Data Conn Release");
nifRequest.status = (AgpsFrameworkInterface::AGnssStatusValue)
LOC_GPS_RELEASE_AGPS_DATA_CONN;
}
mAgpsManager->mFrameworkStatusV4Cb(nifRequest);
return 0;
}
void AgpsStateMachine::notifyAllSubscribers(
AgpsEvent event, bool deleteSubscriberPostNotify,
AgpsNotificationType notificationType){
LOC_LOGD("notifyAllSubscribers(): "
"SM %p, Event %d Delete %d Notification Type %d",
this, event, deleteSubscriberPostNotify, notificationType);
std::list<AgpsSubscriber*>::const_iterator it = mSubscriberList.begin();
while ( it != mSubscriberList.end() ){
AgpsSubscriber* subscriber = *it;
if(notificationType == AGPS_NOTIFICATION_TYPE_FOR_ALL_SUBSCRIBERS ||
(notificationType == AGPS_NOTIFICATION_TYPE_FOR_INACTIVE_SUBSCRIBERS &&
subscriber->mIsInactive) ||
(notificationType == AGPS_NOTIFICATION_TYPE_FOR_ACTIVE_SUBSCRIBERS &&
!subscriber->mIsInactive)) {
/* Deleting via this call would require another traversal
* through subscriber list, inefficient; hence pass in false*/
notifyEventToSubscriber(event, subscriber, false);
if(deleteSubscriberPostNotify){
it = mSubscriberList.erase(it);
delete subscriber;
} else{
it++;
}
} else{
it++;
}
}
}
void AgpsStateMachine::notifyEventToSubscriber(
AgpsEvent event, AgpsSubscriber* subscriberToNotify,
bool deleteSubscriberPostNotify) {
LOC_LOGD("notifyEventToSubscriber(): "
"SM %p, Event %d Subscriber %p Delete %d",
this, event, subscriberToNotify, deleteSubscriberPostNotify);
switch (event){
case AGPS_EVENT_GRANTED:
mAgpsManager->mAtlOpenStatusCb(
subscriberToNotify->mConnHandle, 1, getAPN(),
getBearer(), mAgpsType);
break;
case AGPS_EVENT_DENIED:
mAgpsManager->mAtlOpenStatusCb(
subscriberToNotify->mConnHandle, 0, getAPN(),
getBearer(), mAgpsType);
break;
case AGPS_EVENT_UNSUBSCRIBE:
case AGPS_EVENT_RELEASED:
mAgpsManager->mAtlCloseStatusCb(subscriberToNotify->mConnHandle, 1);
break;
default:
LOC_LOGE("Invalid event %d", event);
}
/* Search this subscriber in list and delete */
if (deleteSubscriberPostNotify) {
deleteSubscriber(subscriberToNotify);
}
}
void AgpsStateMachine::transitionState(AgpsState newState){
LOC_LOGD("transitionState(): SM %p, old %d, new %d",
this, mState, newState);
mState = newState;
// notify state transitions to all subscribers ?
}
void AgpsStateMachine::addSubscriber(AgpsSubscriber* subscriberToAdd){
LOC_LOGD("addSubscriber(): SM %p, Subscriber %p",
this, subscriberToAdd);
// Check if subscriber is already present in the current list
// If not, then add
std::list<AgpsSubscriber*>::const_iterator it = mSubscriberList.begin();
for(; it != mSubscriberList.end(); it++){
AgpsSubscriber* subscriber = *it;
if(subscriber->equals(subscriberToAdd)){
LOC_LOGE("Subscriber already in list");
return;
}
}
AgpsSubscriber* cloned = subscriberToAdd->clone();
LOC_LOGD("addSubscriber(): cloned subscriber: %p", cloned);
mSubscriberList.push_back(cloned);
}
void AgpsStateMachine::deleteSubscriber(AgpsSubscriber* subscriberToDelete){
LOC_LOGD("deleteSubscriber(): SM %p, Subscriber %p",
this, subscriberToDelete);
std::list<AgpsSubscriber*>::const_iterator it = mSubscriberList.begin();
while ( it != mSubscriberList.end() ) {
AgpsSubscriber* subscriber = *it;
if(subscriber && subscriber->equals(subscriberToDelete)){
it = mSubscriberList.erase(it);
delete subscriber;
}else{
it++;
}
}
}
bool AgpsStateMachine::anyActiveSubscribers(){
std::list<AgpsSubscriber*>::const_iterator it = mSubscriberList.begin();
for(; it != mSubscriberList.end(); it++){
AgpsSubscriber* subscriber = *it;
if(!subscriber->mIsInactive){
return true;
}
}
return false;
}
void AgpsStateMachine::setAPN(char* apn, unsigned int len){
if (NULL != mAPN) {
delete mAPN;
}
if(apn == NULL || len <= 0){
LOC_LOGD("Invalid apn len (%d) or null apn", len);
mAPN = NULL;
mAPNLen = 0;
}
if (NULL != apn) {
mAPN = new char[len+1];
memcpy(mAPN, apn, len);
mAPN[len] = '\0';
mAPNLen = len;
}
}
AgpsSubscriber* AgpsStateMachine::getSubscriber(int connHandle){
/* Go over the subscriber list */
std::list<AgpsSubscriber*>::const_iterator it = mSubscriberList.begin();
for(; it != mSubscriberList.end(); it++){
AgpsSubscriber* subscriber = *it;
if(subscriber->mConnHandle == connHandle){
return subscriber;
}
}
/* Not found, return NULL */
return NULL;
}
AgpsSubscriber* AgpsStateMachine::getFirstSubscriber(bool isInactive){
/* Go over the subscriber list */
std::list<AgpsSubscriber*>::const_iterator it = mSubscriberList.begin();
for(; it != mSubscriberList.end(); it++){
AgpsSubscriber* subscriber = *it;
if(subscriber->mIsInactive == isInactive){
return subscriber;
}
}
/* Not found, return NULL */
return NULL;
}
void AgpsStateMachine::dropAllSubscribers(){
LOC_LOGD("dropAllSubscribers(): SM %p", this);
/* Go over the subscriber list */
std::list<AgpsSubscriber*>::const_iterator it = mSubscriberList.begin();
while ( it != mSubscriberList.end() ){
AgpsSubscriber* subscriber = *it;
it = mSubscriberList.erase(it);
delete subscriber;
}
}
/* --------------------------------------------------------------------
* DS State Machine Methods
* -------------------------------------------------------------------*/
const int DSStateMachine::MAX_START_DATA_CALL_RETRIES = 4;
const int DSStateMachine::DATA_CALL_RETRY_DELAY_MSEC = 500;
/* Overridden method
* DS SM needs to handle one scenario differently */
void DSStateMachine::processAgpsEvent(AgpsEvent event){
LOC_LOGD("DSStateMachine::processAgpsEvent() %d", event);
/* DS Client call setup APIs don't return failure/closure separately.
* Hence we receive RELEASED event in both cases.
* If we are in pending, we should consider RELEASED as DENIED */
if(event == AGPS_EVENT_RELEASED && mState == AGPS_STATE_PENDING){
LOC_LOGD("Translating RELEASED to DENIED event");
event = AGPS_EVENT_DENIED;
}
/* Redirect process to base class */
AgpsStateMachine::processAgpsEvent(event);
}
/* Timer Callback
* For the retry timer started in case of DS Client call setup failure */
void delay_callback(void *callbackData, int result)
{
LOC_LOGD("delay_callback(): cbData %p", callbackData);
(void)result;
if(callbackData == NULL) {
LOC_LOGE("delay_callback(): NULL argument received !");
return;
}
DSStateMachine* dsStateMachine = (DSStateMachine *)callbackData;
dsStateMachine->retryCallback();
}
/* Invoked from Timer Callback
* For the retry timer started in case of DS Client call setup failure */
void DSStateMachine :: retryCallback()
{
LOC_LOGD("DSStateMachine::retryCallback()");
/* Request SUPL ES
* There must be at least one active subscriber in list */
AgpsSubscriber* subscriber = getFirstSubscriber(false);
if(subscriber == NULL) {
LOC_LOGE("No active subscriber for DS Client call setup");
return;
}
/* Send message to retry */
mAgpsManager->mSendMsgToAdapterQueueFn(
new AgpsMsgRequestATL(
mAgpsManager, subscriber->mConnHandle,
LOC_AGPS_TYPE_SUPL_ES));
}
/* Overridden method
* Request or Release data connection
* bool request :
* true = Request data connection
* false = Release data connection */
int DSStateMachine::requestOrReleaseDataConn(bool request){
LOC_LOGD("DSStateMachine::requestOrReleaseDataConn(): "
"request %d", request);
/* Release data connection required ? */
if(!request && mAgpsManager->mDSClientStopDataCallFn){
mAgpsManager->mDSClientStopDataCallFn();
LOC_LOGD("DS Client release data call request sent !");
return 0;
}
/* Setup data connection request
* There must be at least one active subscriber in list */
AgpsSubscriber* subscriber = getFirstSubscriber(false);
if(subscriber == NULL) {
LOC_LOGE("No active subscriber for DS Client call setup");
return -1;
}
/* DS Client Fn registered ? */
if(!mAgpsManager->mDSClientOpenAndStartDataCallFn){
LOC_LOGE("DS Client start fn not registered, fallback to SUPL ATL");
notifyEventToSubscriber(AGPS_EVENT_DENIED, subscriber, false);
return -1;
}
/* Setup the call */
int ret = mAgpsManager->mDSClientOpenAndStartDataCallFn();
/* Check if data call start failed */
switch (ret) {
case LOC_API_ADAPTER_ERR_ENGINE_BUSY:
LOC_LOGE("DS Client open call failed, err: %d", ret);
mRetries++;
if(mRetries > MAX_START_DATA_CALL_RETRIES) {
LOC_LOGE("DS Client call retries exhausted, "
"falling back to normal SUPL ATL");
notifyEventToSubscriber(AGPS_EVENT_DENIED, subscriber, false);
}
/* Retry DS Client call setup after some delay */
else if(loc_timer_start(
DATA_CALL_RETRY_DELAY_MSEC, delay_callback, this)) {
LOC_LOGE("Error: Could not start delay thread\n");
return -1;
}
break;
case LOC_API_ADAPTER_ERR_UNSUPPORTED:
LOC_LOGE("No emergency profile found. Fall back to normal SUPL ATL");
notifyEventToSubscriber(AGPS_EVENT_DENIED, subscriber, false);
break;
case LOC_API_ADAPTER_ERR_SUCCESS:
LOC_LOGD("Request to start data call sent");
break;
default:
LOC_LOGE("Unrecognized return value: %d", ret);
}
return ret;
}
void DSStateMachine::notifyEventToSubscriber(
AgpsEvent event, AgpsSubscriber* subscriberToNotify,
bool deleteSubscriberPostNotify) {
LOC_LOGD("DSStateMachine::notifyEventToSubscriber(): "
"SM %p, Event %d Subscriber %p Delete %d",
this, event, subscriberToNotify, deleteSubscriberPostNotify);
switch (event){
case AGPS_EVENT_GRANTED:
mAgpsManager->mAtlOpenStatusCb(
subscriberToNotify->mConnHandle, 1, NULL,
AGPS_APN_BEARER_INVALID, LOC_AGPS_TYPE_SUPL_ES);
break;
case AGPS_EVENT_DENIED:
/* Now try with regular SUPL
* We need to send request via message queue */
mRetries = 0;
mAgpsManager->mSendMsgToAdapterQueueFn(
new AgpsMsgRequestATL(
mAgpsManager, subscriberToNotify->mConnHandle,
LOC_AGPS_TYPE_SUPL));
break;
case AGPS_EVENT_UNSUBSCRIBE:
mAgpsManager->mAtlCloseStatusCb(subscriberToNotify->mConnHandle, 1);
break;
case AGPS_EVENT_RELEASED:
mAgpsManager->mDSClientCloseDataCallFn();
break;
default:
LOC_LOGE("Invalid event %d", event);
}
/* Search this subscriber in list and delete */
if (deleteSubscriberPostNotify) {
deleteSubscriber(subscriberToNotify);
}
}
/* --------------------------------------------------------------------
* Loc AGPS Manager Methods
* -------------------------------------------------------------------*/
/* CREATE AGPS STATE MACHINES
* Must be invoked in Msg Handler context */
void AgpsManager::createAgpsStateMachines() {
LOC_LOGD("AgpsManager::createAgpsStateMachines");
bool agpsCapable =
((loc_core::ContextBase::mGps_conf.CAPABILITIES & LOC_GPS_CAPABILITY_MSA) ||
(loc_core::ContextBase::mGps_conf.CAPABILITIES & LOC_GPS_CAPABILITY_MSB));
if (NULL == mInternetNif) {
mInternetNif = new AgpsStateMachine(this, LOC_AGPS_TYPE_WWAN_ANY);
LOC_LOGD("Internet NIF: %p", mInternetNif);
}
if (agpsCapable) {
if (NULL == mAgnssNif) {
mAgnssNif = new AgpsStateMachine(this, LOC_AGPS_TYPE_SUPL);
LOC_LOGD("AGNSS NIF: %p", mAgnssNif);
}
if (NULL == mDsNif &&
loc_core::ContextBase::mGps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL){
if(!mDSClientInitFn){
LOC_LOGE("DS Client Init Fn not registered !");
return;
}
if(mDSClientInitFn(false) != 0){
LOC_LOGE("Failed to init data service client");
return;
}
mDsNif = new DSStateMachine(this);
LOC_LOGD("DS NIF: %p", mDsNif);
}
}
}
AgpsStateMachine* AgpsManager::getAgpsStateMachine(AGpsExtType agpsType) {
LOC_LOGD("AgpsManager::getAgpsStateMachine(): agpsType %d", agpsType);
switch (agpsType) {
case LOC_AGPS_TYPE_INVALID:
case LOC_AGPS_TYPE_SUPL:
if(mAgnssNif == NULL){
LOC_LOGE("NULL AGNSS NIF !");
}
return mAgnssNif;
case LOC_AGPS_TYPE_SUPL_ES:
if (loc_core::ContextBase::mGps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL) {
if (mDsNif == NULL) {
createAgpsStateMachines();
}
return mDsNif;
} else {
return mAgnssNif;
}
default:
return mInternetNif;
}
LOC_LOGE("No SM found !");
return NULL;
}
void AgpsManager::requestATL(int connHandle, AGpsExtType agpsType){
LOC_LOGD("AgpsManager::requestATL(): connHandle %d, agpsType %d",
connHandle, agpsType);
AgpsStateMachine* sm = getAgpsStateMachine(agpsType);
if(sm == NULL){
LOC_LOGE("No AGPS State Machine for agpsType: %d", agpsType);
mAtlOpenStatusCb(
connHandle, 0, NULL, AGPS_APN_BEARER_INVALID, agpsType);
return;
}
/* Invoke AGPS SM processing */
AgpsSubscriber subscriber(connHandle, false, false);
sm->setCurrentSubscriber(&subscriber);
/* If DS State Machine, wait for close complete */
if(agpsType == LOC_AGPS_TYPE_SUPL_ES){
subscriber.mWaitForCloseComplete = true;
}
/* Send subscriber event */
sm->processAgpsEvent(AGPS_EVENT_SUBSCRIBE);
}
void AgpsManager::releaseATL(int connHandle){
LOC_LOGD("AgpsManager::releaseATL(): connHandle %d", connHandle);
/* First find the subscriber with specified handle.
* We need to search in all state machines. */
AgpsStateMachine* sm = NULL;
AgpsSubscriber* subscriber = NULL;
if (mAgnssNif &&
(subscriber = mAgnssNif->getSubscriber(connHandle)) != NULL) {
sm = mAgnssNif;
}
else if (mInternetNif &&
(subscriber = mInternetNif->getSubscriber(connHandle)) != NULL) {
sm = mInternetNif;
}
else if (mDsNif &&
(subscriber = mDsNif->getSubscriber(connHandle)) != NULL) {
sm = mDsNif;
}
if(sm == NULL){
LOC_LOGE("Subscriber with connHandle %d not found in any SM",
connHandle);
mAtlCloseStatusCb(connHandle, 0);
return;
}
/* Now send unsubscribe event */
sm->setCurrentSubscriber(subscriber);
sm->processAgpsEvent(AGPS_EVENT_UNSUBSCRIBE);
}
void AgpsManager::reportDataCallOpened(){
LOC_LOGD("AgpsManager::reportDataCallOpened");
if (mDsNif) {
mDsNif->processAgpsEvent(AGPS_EVENT_GRANTED);
}
}
void AgpsManager::reportDataCallClosed(){
LOC_LOGD("AgpsManager::reportDataCallClosed");
if (mDsNif) {
mDsNif->processAgpsEvent(AGPS_EVENT_RELEASED);
}
}
void AgpsManager::reportAtlOpenSuccess(
AGpsExtType agpsType, char* apnName, int apnLen,
LocApnIpType ipType){
LOC_LOGD("AgpsManager::reportAtlOpenSuccess(): "
"AgpsType %d, APN [%s], Len %d, IPType %d",
agpsType, apnName, apnLen, ipType);
/* Find the state machine instance */
AgpsStateMachine* sm = getAgpsStateMachine(agpsType);
/* Convert LocApnIpType sent by framework to AGpsBearerType */
AGpsBearerType bearerType;
switch (ipType) {
case LOC_APN_IP_IPV4:
bearerType = AGPS_APN_BEARER_IPV4;
break;
case LOC_APN_IP_IPV6:
bearerType = AGPS_APN_BEARER_IPV6;
break;
case LOC_APN_IP_IPV4V6:
bearerType = AGPS_APN_BEARER_IPV4V6;
break;
default:
bearerType = AGPS_APN_BEARER_IPV4;
break;
}
/* Set bearer and apn info in state machine instance */
sm->setBearer(bearerType);
sm->setAPN(apnName, apnLen);
/* Send GRANTED event to state machine */
sm->processAgpsEvent(AGPS_EVENT_GRANTED);
}
void AgpsManager::reportAtlOpenFailed(AGpsExtType agpsType){
LOC_LOGD("AgpsManager::reportAtlOpenFailed(): AgpsType %d", agpsType);
/* Fetch SM and send DENIED event */
AgpsStateMachine* sm = getAgpsStateMachine(agpsType);
sm->processAgpsEvent(AGPS_EVENT_DENIED);
}
void AgpsManager::reportAtlClosed(AGpsExtType agpsType){
LOC_LOGD("AgpsManager::reportAtlClosed(): AgpsType %d", agpsType);
/* Fetch SM and send RELEASED event */
AgpsStateMachine* sm = getAgpsStateMachine(agpsType);
sm->processAgpsEvent(AGPS_EVENT_RELEASED);
}
void AgpsManager::handleModemSSR(){
LOC_LOGD("AgpsManager::handleModemSSR");
/* Drop subscribers from all state machines */
if (mAgnssNif){
mAgnssNif->dropAllSubscribers();
}
if (mInternetNif){
mInternetNif->dropAllSubscribers();
}
if(mDsNif){
mDsNif->dropAllSubscribers();
}
// reinitialize DS client in SSR mode
if(loc_core::ContextBase::mGps_conf.
USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL){
mDSClientStopDataCallFn();
mDSClientCloseDataCallFn();
mDSClientReleaseFn();
mDSClientInitFn(true);
}
}
AGpsBearerType AgpsUtils::ipTypeToBearerType(LocApnIpType ipType) {
switch (ipType) {
case LOC_APN_IP_IPV4:
return AGPS_APN_BEARER_IPV4;
case LOC_APN_IP_IPV6:
return AGPS_APN_BEARER_IPV6;
case LOC_APN_IP_IPV4V6:
return AGPS_APN_BEARER_IPV4V6;
default:
return AGPS_APN_BEARER_IPV4;
}
}
LocApnIpType AgpsUtils::bearerTypeToIpType(AGpsBearerType bearerType){
switch (bearerType) {
case AGPS_APN_BEARER_IPV4:
return LOC_APN_IP_IPV4;
case AGPS_APN_BEARER_IPV6:
return LOC_APN_IP_IPV6;
case AGPS_APN_BEARER_IPV4V6:
return LOC_APN_IP_IPV4V6;
default:
return LOC_APN_IP_IPV4;
}
}