• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /* Copyright (c) 2012-2019, The Linux Foundation. All rights reserved.
2  *
3  * Redistribution and use in source and binary forms, with or without
4  * modification, are permitted provided that the following conditions are
5  * met:
6  *     * Redistributions of source code must retain the above copyright
7  *       notice, this list of conditions and the following disclaimer.
8  *     * Redistributions in binary form must reproduce the above
9  *       copyright notice, this list of conditions and the following
10  *       disclaimer in the documentation and/or other materials provided
11  *       with the distribution.
12  *     * Neither the name of The Linux Foundation, nor the names of its
13  *       contributors may be used to endorse or promote products derived
14  *       from this software without specific prior written permission.
15  *
16  * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
17  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
18  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
20  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
23  * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
24  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
25  * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
26  * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  *
28  */
29 #define LOG_NDEBUG 0
30 #define LOG_TAG "LocSvc_Agps"
31 
32 #include <Agps.h>
33 #include <loc_pla.h>
34 #include <ContextBase.h>
35 #include <loc_timer.h>
36 #include <inttypes.h>
37 
38 /* --------------------------------------------------------------------
39  *   AGPS State Machine Methods
40  * -------------------------------------------------------------------*/
processAgpsEvent(AgpsEvent event)41 void AgpsStateMachine::processAgpsEvent(AgpsEvent event){
42 
43     LOC_LOGD("processAgpsEvent(): SM %p, Event %d, State %d",
44                this, event, mState);
45 
46     switch (event) {
47 
48         case AGPS_EVENT_SUBSCRIBE:
49             processAgpsEventSubscribe();
50             break;
51 
52         case AGPS_EVENT_UNSUBSCRIBE:
53             processAgpsEventUnsubscribe();
54             break;
55 
56         case AGPS_EVENT_GRANTED:
57             processAgpsEventGranted();
58             break;
59 
60         case AGPS_EVENT_RELEASED:
61             processAgpsEventReleased();
62             break;
63 
64         case AGPS_EVENT_DENIED:
65             processAgpsEventDenied();
66             break;
67 
68         default:
69             LOC_LOGE("Invalid Loc Agps Event");
70     }
71 }
72 
processAgpsEventSubscribe()73 void AgpsStateMachine::processAgpsEventSubscribe(){
74 
75     switch (mState) {
76 
77         case AGPS_STATE_RELEASED:
78             /* Add subscriber to list
79              * No notifications until we get RSRC_GRANTED */
80             addSubscriber(mCurrentSubscriber);
81             requestOrReleaseDataConn(true);
82             transitionState(AGPS_STATE_PENDING);
83             break;
84 
85         case AGPS_STATE_PENDING:
86             /* Already requested for data connection,
87              * do nothing until we get RSRC_GRANTED event;
88              * Just add this subscriber to the list, for notifications */
89             addSubscriber(mCurrentSubscriber);
90             break;
91 
92         case AGPS_STATE_ACQUIRED:
93             /* We already have the data connection setup,
94              * Notify current subscriber with GRANTED event,
95              * And add it to the subscriber list for further notifications. */
96             notifyEventToSubscriber(AGPS_EVENT_GRANTED, mCurrentSubscriber, false);
97             addSubscriber(mCurrentSubscriber);
98             break;
99 
100         case AGPS_STATE_RELEASING:
101             addSubscriber(mCurrentSubscriber);
102             break;
103 
104         default:
105             LOC_LOGE("Invalid state: %d", mState);
106     }
107 }
108 
processAgpsEventUnsubscribe()109 void AgpsStateMachine::processAgpsEventUnsubscribe(){
110 
111     switch (mState) {
112 
113         case AGPS_STATE_RELEASED:
114             notifyEventToSubscriber(
115                     AGPS_EVENT_UNSUBSCRIBE, mCurrentSubscriber, false);
116             break;
117 
118         case AGPS_STATE_PENDING:
119         case AGPS_STATE_ACQUIRED:
120             /* If the subscriber wishes to wait for connection close,
121              * before being removed from list, move to inactive state
122              * and notify */
123             if (mCurrentSubscriber->mWaitForCloseComplete) {
124                 mCurrentSubscriber->mIsInactive = true;
125             }
126             else {
127                 /* Notify only current subscriber and then delete it from
128                  * subscriberList */
129                 notifyEventToSubscriber(
130                         AGPS_EVENT_UNSUBSCRIBE, mCurrentSubscriber, true);
131             }
132 
133             /* If no subscribers in list, release data connection */
134             if (mSubscriberList.empty()) {
135                 transitionState(AGPS_STATE_RELEASED);
136                 requestOrReleaseDataConn(false);
137             }
138             /* Some subscribers in list, but all inactive;
139              * Release data connection */
140             else if(!anyActiveSubscribers()) {
141                 transitionState(AGPS_STATE_RELEASING);
142                 requestOrReleaseDataConn(false);
143             }
144             break;
145 
146         case AGPS_STATE_RELEASING:
147             /* If the subscriber wishes to wait for connection close,
148              * before being removed from list, move to inactive state
149              * and notify */
150             if (mCurrentSubscriber->mWaitForCloseComplete) {
151                 mCurrentSubscriber->mIsInactive = true;
152             }
153             else {
154                 /* Notify only current subscriber and then delete it from
155                  * subscriberList */
156                 notifyEventToSubscriber(
157                         AGPS_EVENT_UNSUBSCRIBE, mCurrentSubscriber, true);
158             }
159 
160             /* If no subscribers in list, just move the state.
161              * Request for releasing data connection should already have been
162              * sent */
163             if (mSubscriberList.empty()) {
164                 transitionState(AGPS_STATE_RELEASED);
165             }
166             break;
167 
168         default:
169             LOC_LOGE("Invalid state: %d", mState);
170     }
171 }
172 
processAgpsEventGranted()173 void AgpsStateMachine::processAgpsEventGranted(){
174 
175     switch (mState) {
176 
177         case AGPS_STATE_RELEASED:
178         case AGPS_STATE_ACQUIRED:
179         case AGPS_STATE_RELEASING:
180             LOC_LOGE("Unexpected event GRANTED in state %d", mState);
181             break;
182 
183         case AGPS_STATE_PENDING:
184             // Move to acquired state
185             transitionState(AGPS_STATE_ACQUIRED);
186             notifyAllSubscribers(
187                     AGPS_EVENT_GRANTED, false,
188                     AGPS_NOTIFICATION_TYPE_FOR_ACTIVE_SUBSCRIBERS);
189             break;
190 
191         default:
192             LOC_LOGE("Invalid state: %d", mState);
193     }
194 }
195 
processAgpsEventReleased()196 void AgpsStateMachine::processAgpsEventReleased(){
197 
198     switch (mState) {
199 
200         case AGPS_STATE_RELEASED:
201             /* Subscriber list should be empty if we are in released state */
202             if (!mSubscriberList.empty()) {
203                 LOC_LOGE("Unexpected event RELEASED in RELEASED state");
204             }
205             break;
206 
207         case AGPS_STATE_ACQUIRED:
208             /* Force release received */
209             LOC_LOGW("Force RELEASED event in ACQUIRED state");
210             transitionState(AGPS_STATE_RELEASED);
211             notifyAllSubscribers(
212                     AGPS_EVENT_RELEASED, true,
213                     AGPS_NOTIFICATION_TYPE_FOR_ALL_SUBSCRIBERS);
214             break;
215 
216         case AGPS_STATE_RELEASING:
217             /* Notify all inactive subscribers about the event */
218             notifyAllSubscribers(
219                     AGPS_EVENT_RELEASED, true,
220                     AGPS_NOTIFICATION_TYPE_FOR_INACTIVE_SUBSCRIBERS);
221 
222             /* If we have active subscribers now, they must be waiting for
223              * data conn setup */
224             if (anyActiveSubscribers()) {
225                 transitionState(AGPS_STATE_PENDING);
226                 requestOrReleaseDataConn(true);
227             }
228             /* No active subscribers, move to released state */
229             else {
230                 transitionState(AGPS_STATE_RELEASED);
231             }
232             break;
233 
234         case AGPS_STATE_PENDING:
235             /* NOOP */
236             break;
237 
238         default:
239             LOC_LOGE("Invalid state: %d", mState);
240     }
241 }
242 
processAgpsEventDenied()243 void AgpsStateMachine::processAgpsEventDenied(){
244 
245     switch (mState) {
246 
247         case AGPS_STATE_RELEASED:
248             LOC_LOGE("Unexpected event DENIED in state %d", mState);
249             break;
250 
251         case AGPS_STATE_ACQUIRED:
252             /* NOOP */
253             break;
254 
255         case AGPS_STATE_RELEASING:
256             /* Notify all inactive subscribers about the event */
257             notifyAllSubscribers(
258                     AGPS_EVENT_RELEASED, true,
259                     AGPS_NOTIFICATION_TYPE_FOR_INACTIVE_SUBSCRIBERS);
260 
261             /* If we have active subscribers now, they must be waiting for
262              * data conn setup */
263             if (anyActiveSubscribers()) {
264                 transitionState(AGPS_STATE_PENDING);
265                 requestOrReleaseDataConn(true);
266             }
267             /* No active subscribers, move to released state */
268             else {
269                 transitionState(AGPS_STATE_RELEASED);
270             }
271             break;
272 
273         case AGPS_STATE_PENDING:
274             transitionState(AGPS_STATE_RELEASED);
275             notifyAllSubscribers(
276                     AGPS_EVENT_DENIED, true,
277                     AGPS_NOTIFICATION_TYPE_FOR_ALL_SUBSCRIBERS);
278             break;
279 
280         default:
281             LOC_LOGE("Invalid state: %d", mState);
282     }
283 }
284 
285 /* Request or Release data connection
286  * bool request :
287  *      true  = Request data connection
288  *      false = Release data connection */
requestOrReleaseDataConn(bool request)289 void AgpsStateMachine::requestOrReleaseDataConn(bool request){
290 
291     AGnssExtStatusIpV4 nifRequest;
292     memset(&nifRequest, 0, sizeof(nifRequest));
293 
294     nifRequest.type = mAgpsType;
295     nifRequest.apnTypeMask = mApnTypeMask;
296     if (request) {
297         LOC_LOGD("AGPS Data Conn Request mAgpsType=%d mApnTypeMask=0x%X",
298                  mAgpsType, mApnTypeMask);
299         nifRequest.status = LOC_GPS_REQUEST_AGPS_DATA_CONN;
300     }
301     else{
302         LOC_LOGD("AGPS Data Conn Release mAgpsType=%d mApnTypeMask=0x%X",
303                  mAgpsType, mApnTypeMask);
304         nifRequest.status = LOC_GPS_RELEASE_AGPS_DATA_CONN;
305     }
306 
307     mFrameworkStatusV4Cb(nifRequest);
308 }
309 
notifyAllSubscribers(AgpsEvent event,bool deleteSubscriberPostNotify,AgpsNotificationType notificationType)310 void AgpsStateMachine::notifyAllSubscribers(
311         AgpsEvent event, bool deleteSubscriberPostNotify,
312         AgpsNotificationType notificationType){
313 
314     LOC_LOGD("notifyAllSubscribers(): "
315             "SM %p, Event %d Delete %d Notification Type %d",
316             this, event, deleteSubscriberPostNotify, notificationType);
317 
318     std::list<AgpsSubscriber*>::const_iterator it = mSubscriberList.begin();
319     while ( it != mSubscriberList.end() ) {
320 
321         AgpsSubscriber* subscriber = *it;
322 
323         if (notificationType == AGPS_NOTIFICATION_TYPE_FOR_ALL_SUBSCRIBERS ||
324                 (notificationType == AGPS_NOTIFICATION_TYPE_FOR_INACTIVE_SUBSCRIBERS &&
325                         subscriber->mIsInactive) ||
326                 (notificationType == AGPS_NOTIFICATION_TYPE_FOR_ACTIVE_SUBSCRIBERS &&
327                         !subscriber->mIsInactive)) {
328 
329             /* Deleting via this call would require another traversal
330              * through subscriber list, inefficient; hence pass in false*/
331             notifyEventToSubscriber(event, subscriber, false);
332 
333             if (deleteSubscriberPostNotify) {
334                 it = mSubscriberList.erase(it);
335                 delete subscriber;
336             } else {
337                 it++;
338             }
339         } else {
340             it++;
341         }
342     }
343 }
344 
notifyEventToSubscriber(AgpsEvent event,AgpsSubscriber * subscriberToNotify,bool deleteSubscriberPostNotify)345 void AgpsStateMachine::notifyEventToSubscriber(
346         AgpsEvent event, AgpsSubscriber* subscriberToNotify,
347         bool deleteSubscriberPostNotify) {
348 
349     LOC_LOGD("notifyEventToSubscriber(): "
350             "SM %p, Event %d Subscriber %p Delete %d",
351             this, event, subscriberToNotify, deleteSubscriberPostNotify);
352 
353     switch (event) {
354 
355         case AGPS_EVENT_GRANTED:
356             mAgpsManager->mAtlOpenStatusCb(
357                     subscriberToNotify->mConnHandle, 1, getAPN(), getAPNLen(),
358                     getBearer(), mAgpsType, mApnTypeMask);
359             break;
360 
361         case AGPS_EVENT_DENIED:
362             mAgpsManager->mAtlOpenStatusCb(
363                     subscriberToNotify->mConnHandle, 0, getAPN(), getAPNLen(),
364                     getBearer(), mAgpsType, mApnTypeMask);
365             break;
366 
367         case AGPS_EVENT_UNSUBSCRIBE:
368         case AGPS_EVENT_RELEASED:
369             mAgpsManager->mAtlCloseStatusCb(subscriberToNotify->mConnHandle, 1);
370             break;
371 
372         default:
373             LOC_LOGE("Invalid event %d", event);
374     }
375 
376     /* Search this subscriber in list and delete */
377     if (deleteSubscriberPostNotify) {
378         deleteSubscriber(subscriberToNotify);
379     }
380 }
381 
transitionState(AgpsState newState)382 void AgpsStateMachine::transitionState(AgpsState newState){
383 
384     LOC_LOGD("transitionState(): SM %p, old %d, new %d",
385                this, mState, newState);
386 
387     mState = newState;
388 
389     // notify state transitions to all subscribers ?
390 }
391 
addSubscriber(AgpsSubscriber * subscriberToAdd)392 void AgpsStateMachine::addSubscriber(AgpsSubscriber* subscriberToAdd){
393 
394     LOC_LOGD("addSubscriber(): SM %p, Subscriber %p",
395                this, subscriberToAdd);
396 
397     // Check if subscriber is already present in the current list
398     // If not, then add
399     std::list<AgpsSubscriber*>::const_iterator it = mSubscriberList.begin();
400     for (; it != mSubscriberList.end(); it++) {
401         AgpsSubscriber* subscriber = *it;
402         if (subscriber->equals(subscriberToAdd)) {
403             LOC_LOGE("Subscriber already in list");
404             return;
405         }
406     }
407 
408     AgpsSubscriber* cloned = subscriberToAdd->clone();
409     LOC_LOGD("addSubscriber(): cloned subscriber: %p", cloned);
410     mSubscriberList.push_back(cloned);
411 }
412 
deleteSubscriber(AgpsSubscriber * subscriberToDelete)413 void AgpsStateMachine::deleteSubscriber(AgpsSubscriber* subscriberToDelete){
414 
415     LOC_LOGD("deleteSubscriber(): SM %p, Subscriber %p",
416                this, subscriberToDelete);
417 
418     std::list<AgpsSubscriber*>::const_iterator it = mSubscriberList.begin();
419     while ( it != mSubscriberList.end() ) {
420 
421         AgpsSubscriber* subscriber = *it;
422         if (subscriber && subscriber->equals(subscriberToDelete)) {
423 
424             it = mSubscriberList.erase(it);
425             delete subscriber;
426         } else {
427             it++;
428         }
429     }
430 }
431 
anyActiveSubscribers()432 bool AgpsStateMachine::anyActiveSubscribers(){
433 
434     std::list<AgpsSubscriber*>::const_iterator it = mSubscriberList.begin();
435     for (; it != mSubscriberList.end(); it++) {
436         AgpsSubscriber* subscriber = *it;
437         if (!subscriber->mIsInactive) {
438             return true;
439         }
440     }
441     return false;
442 }
443 
setAPN(char * apn,unsigned int len)444 void AgpsStateMachine::setAPN(char* apn, unsigned int len){
445 
446     if (NULL != mAPN) {
447         delete mAPN;
448         mAPN  = NULL;
449     }
450 
451     if (NULL == apn || len > MAX_APN_LEN || strlen(apn) != len) {
452         LOC_LOGD("Invalid apn len (%d) or null apn", len);
453         mAPN = NULL;
454         mAPNLen = 0;
455     } else {
456         mAPN = new char[len+1];
457         if (NULL != mAPN) {
458             memcpy(mAPN, apn, len);
459             mAPN[len] = '\0';
460             mAPNLen = len;
461         }
462     }
463 }
464 
getSubscriber(int connHandle)465 AgpsSubscriber* AgpsStateMachine::getSubscriber(int connHandle){
466 
467     /* Go over the subscriber list */
468     std::list<AgpsSubscriber*>::const_iterator it = mSubscriberList.begin();
469     for (; it != mSubscriberList.end(); it++) {
470         AgpsSubscriber* subscriber = *it;
471         if (subscriber->mConnHandle == connHandle) {
472             return subscriber;
473         }
474     }
475 
476     /* Not found, return NULL */
477     return NULL;
478 }
479 
getFirstSubscriber(bool isInactive)480 AgpsSubscriber* AgpsStateMachine::getFirstSubscriber(bool isInactive){
481 
482     /* Go over the subscriber list */
483     std::list<AgpsSubscriber*>::const_iterator it = mSubscriberList.begin();
484     for (; it != mSubscriberList.end(); it++) {
485         AgpsSubscriber* subscriber = *it;
486         if(subscriber->mIsInactive == isInactive) {
487             return subscriber;
488         }
489     }
490 
491     /* Not found, return NULL */
492     return NULL;
493 }
494 
dropAllSubscribers()495 void AgpsStateMachine::dropAllSubscribers(){
496 
497     LOC_LOGD("dropAllSubscribers(): SM %p", this);
498 
499     /* Go over the subscriber list */
500     std::list<AgpsSubscriber*>::const_iterator it = mSubscriberList.begin();
501     while ( it != mSubscriberList.end() ) {
502         AgpsSubscriber* subscriber = *it;
503         it = mSubscriberList.erase(it);
504         delete subscriber;
505     }
506 }
507 
508 /* --------------------------------------------------------------------
509  *   Loc AGPS Manager Methods
510  * -------------------------------------------------------------------*/
511 
512 /* CREATE AGPS STATE MACHINES
513  * Must be invoked in Msg Handler context */
createAgpsStateMachines(const AgpsCbInfo & cbInfo)514 void AgpsManager::createAgpsStateMachines(const AgpsCbInfo& cbInfo) {
515 
516     LOC_LOGD("AgpsManager::createAgpsStateMachines");
517 
518     bool agpsCapable =
519             ((loc_core::ContextBase::mGps_conf.CAPABILITIES & LOC_GPS_CAPABILITY_MSA) ||
520                     (loc_core::ContextBase::mGps_conf.CAPABILITIES & LOC_GPS_CAPABILITY_MSB));
521 
522     if (NULL == mInternetNif && (cbInfo.atlType & AGPS_ATL_TYPE_WWAN)) {
523         mInternetNif = new AgpsStateMachine(this, LOC_AGPS_TYPE_WWAN_ANY);
524         mInternetNif->registerFrameworkStatusCallback((AgnssStatusIpV4Cb)cbInfo.statusV4Cb);
525         LOC_LOGD("Internet NIF: %p", mInternetNif);
526     }
527     if (agpsCapable) {
528         if (NULL == mAgnssNif && (cbInfo.atlType & AGPS_ATL_TYPE_SUPL) &&
529                 (cbInfo.atlType & AGPS_ATL_TYPE_SUPL_ES)) {
530             mAgnssNif = new AgpsStateMachine(this, LOC_AGPS_TYPE_SUPL);
531             mAgnssNif->registerFrameworkStatusCallback((AgnssStatusIpV4Cb)cbInfo.statusV4Cb);
532             LOC_LOGD("AGNSS NIF: %p", mAgnssNif);
533         }
534     }
535 }
536 
getAgpsStateMachine(AGpsExtType agpsType)537 AgpsStateMachine* AgpsManager::getAgpsStateMachine(AGpsExtType agpsType) {
538 
539     LOC_LOGD("AgpsManager::getAgpsStateMachine(): agpsType %d", agpsType);
540 
541     switch (agpsType) {
542 
543         case LOC_AGPS_TYPE_INVALID:
544         case LOC_AGPS_TYPE_SUPL:
545         case LOC_AGPS_TYPE_SUPL_ES:
546             if (mAgnssNif == NULL) {
547                 LOC_LOGE("NULL AGNSS NIF !");
548             }
549             return mAgnssNif;
550         case LOC_AGPS_TYPE_WWAN_ANY:
551             if (mInternetNif == NULL) {
552                 LOC_LOGE("NULL Internet NIF !");
553             }
554             return mInternetNif;
555         default:
556             return mInternetNif;
557     }
558 
559     LOC_LOGE("No SM found !");
560     return NULL;
561 }
562 
requestATL(int connHandle,AGpsExtType agpsType,LocApnTypeMask apnTypeMask)563 void AgpsManager::requestATL(int connHandle, AGpsExtType agpsType,
564                              LocApnTypeMask apnTypeMask){
565 
566     LOC_LOGD("AgpsManager::requestATL(): connHandle %d, agpsType 0x%X apnTypeMask: 0x%X",
567                connHandle, agpsType, apnTypeMask);
568 
569     if (0 == loc_core::ContextBase::mGps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL &&
570         LOC_AGPS_TYPE_SUPL_ES == agpsType) {
571         agpsType = LOC_AGPS_TYPE_SUPL;
572         apnTypeMask &= ~LOC_APN_TYPE_MASK_EMERGENCY;
573         apnTypeMask |= LOC_APN_TYPE_MASK_SUPL;
574         LOC_LOGD("Changed agpsType to non-emergency when USE_EMERGENCY... is 0"
575                  "and removed LOC_APN_TYPE_MASK_EMERGENCY from apnTypeMask"
576                  "agpsType 0x%X apnTypeMask : 0x%X",
577                  agpsType, apnTypeMask);
578     }
579     AgpsStateMachine* sm = getAgpsStateMachine(agpsType);
580 
581     if (sm == NULL) {
582 
583         LOC_LOGE("No AGPS State Machine for agpsType: %d apnTypeMask: 0x%X",
584                  agpsType, apnTypeMask);
585         mAtlOpenStatusCb(
586                 connHandle, 0, NULL, 0, AGPS_APN_BEARER_INVALID, agpsType, apnTypeMask);
587         return;
588     }
589     sm->setType(agpsType);
590     sm->setApnTypeMask(apnTypeMask);
591 
592     /* Invoke AGPS SM processing */
593     AgpsSubscriber subscriber(connHandle, true, false, apnTypeMask);
594     sm->setCurrentSubscriber(&subscriber);
595     /* Send subscriber event */
596     sm->processAgpsEvent(AGPS_EVENT_SUBSCRIBE);
597 }
598 
releaseATL(int connHandle)599 void AgpsManager::releaseATL(int connHandle){
600 
601     LOC_LOGD("AgpsManager::releaseATL(): connHandle %d", connHandle);
602 
603     /* First find the subscriber with specified handle.
604      * We need to search in all state machines. */
605     AgpsStateMachine* sm = NULL;
606     AgpsSubscriber* subscriber = NULL;
607 
608     if (mAgnssNif &&
609             (subscriber = mAgnssNif->getSubscriber(connHandle)) != NULL) {
610         sm = mAgnssNif;
611     }
612     else if (mInternetNif &&
613             (subscriber = mInternetNif->getSubscriber(connHandle)) != NULL) {
614         sm = mInternetNif;
615     }
616     if (sm == NULL) {
617         LOC_LOGE("Subscriber with connHandle %d not found in any SM",
618                     connHandle);
619         return;
620     }
621 
622     /* Now send unsubscribe event */
623     sm->setCurrentSubscriber(subscriber);
624     sm->processAgpsEvent(AGPS_EVENT_UNSUBSCRIBE);
625 }
626 
reportAtlOpenSuccess(AGpsExtType agpsType,char * apnName,int apnLen,AGpsBearerType bearerType)627 void AgpsManager::reportAtlOpenSuccess(
628         AGpsExtType agpsType, char* apnName, int apnLen,
629         AGpsBearerType bearerType){
630 
631     LOC_LOGD("AgpsManager::reportAtlOpenSuccess(): "
632              "AgpsType %d, APN [%s], Len %d, BearerType %d",
633              agpsType, apnName, apnLen, bearerType);
634 
635     /* Find the state machine instance */
636     AgpsStateMachine* sm = getAgpsStateMachine(agpsType);
637 
638     /* Set bearer and apn info in state machine instance */
639     sm->setBearer(bearerType);
640     sm->setAPN(apnName, apnLen);
641 
642     /* Send GRANTED event to state machine */
643     sm->processAgpsEvent(AGPS_EVENT_GRANTED);
644 }
645 
reportAtlOpenFailed(AGpsExtType agpsType)646 void AgpsManager::reportAtlOpenFailed(AGpsExtType agpsType){
647 
648     LOC_LOGD("AgpsManager::reportAtlOpenFailed(): AgpsType %d", agpsType);
649 
650     /* Fetch SM and send DENIED event */
651     AgpsStateMachine* sm = getAgpsStateMachine(agpsType);
652     sm->processAgpsEvent(AGPS_EVENT_DENIED);
653 }
654 
reportAtlClosed(AGpsExtType agpsType)655 void AgpsManager::reportAtlClosed(AGpsExtType agpsType){
656 
657     LOC_LOGD("AgpsManager::reportAtlClosed(): AgpsType %d", agpsType);
658 
659     /* Fetch SM and send RELEASED event */
660     AgpsStateMachine* sm = getAgpsStateMachine(agpsType);
661     sm->processAgpsEvent(AGPS_EVENT_RELEASED);
662 }
663 
handleModemSSR()664 void AgpsManager::handleModemSSR(){
665 
666     LOC_LOGD("AgpsManager::handleModemSSR");
667 
668     /* Drop subscribers from all state machines */
669     if (mAgnssNif) {
670         mAgnssNif->dropAllSubscribers();
671     }
672     if (mInternetNif) {
673         mInternetNif->dropAllSubscribers();
674     }
675 }
676