135 // CWlanBgScan::~CWlanBgScan |
132 // CWlanBgScan::~CWlanBgScan |
136 // --------------------------------------------------------------------------- |
133 // --------------------------------------------------------------------------- |
137 // |
134 // |
138 CWlanBgScan::~CWlanBgScan() |
135 CWlanBgScan::~CWlanBgScan() |
139 { |
136 { |
140 DEBUG( "CWlanBgScan::CWlanBgScan()" ); |
137 DEBUG1( "CWlanBgScan::~CWlanBgScan() - deallocating iAwsComms @ 0x%08X", iAwsComms ); |
|
138 delete iAwsComms; |
|
139 iAwsComms = NULL; |
141 } |
140 } |
142 |
141 |
143 // --------------------------------------------------------------------------- |
142 // --------------------------------------------------------------------------- |
144 // From class MWlanBgScanProvider. |
143 // From class MWlanBgScanProvider. |
145 // CWlanBgScan::ScanComplete |
144 // CWlanBgScan::ScanComplete |
146 // --------------------------------------------------------------------------- |
145 // --------------------------------------------------------------------------- |
147 // |
146 // |
148 void CWlanBgScan::ScanComplete() |
147 void CWlanBgScan::ScanComplete() |
149 { |
148 { |
150 DEBUG1( "CWlanBgScan::ScanComplete() - current interval %us", GetInterval() ); |
149 DEBUG1( "CWlanBgScan::ScanComplete() - current interval %us", GetBgInterval() ); |
151 |
150 |
152 if ( GetInterval() != KWlanBgScanIntervalNever ) |
151 if ( GetBgInterval() != KWlanBgScanIntervalNever ) |
153 { |
152 { |
154 DEBUG1( "CWlanBgScan::ScanComplete() - issue a new request with %us as expiry", GetInterval() ); |
153 DEBUG1( "CWlanBgScan::ScanComplete() - issue a new request with %us as expiry", GetBgInterval() ); |
155 iProvider.Scan( GetInterval() ); |
154 iProvider.Scan( GetBgInterval() ); |
156 } |
155 } |
157 } |
|
158 |
|
159 // --------------------------------------------------------------------------- |
|
160 // From class MWlanBgScanProvider. |
|
161 // CWlanBgScan::IntervalChanged |
|
162 // --------------------------------------------------------------------------- |
|
163 // |
|
164 void CWlanBgScan::IntervalChanged( TUint32 aNewInterval ) |
|
165 { |
|
166 DEBUG1( "CWlanBgScan::IntervalChanged() - aNewInterval %u", aNewInterval ); |
|
167 |
|
168 NextState( aNewInterval ); |
|
169 |
|
170 DEBUG2( "CWlanBgScan::IntervalChanged() - current interval %u, current state %u", |
|
171 GetInterval(), |
|
172 iBgScanState ); |
|
173 } |
156 } |
174 |
157 |
175 // --------------------------------------------------------------------------- |
158 // --------------------------------------------------------------------------- |
176 // From class MWlanBgScanProvider. |
159 // From class MWlanBgScanProvider. |
177 // CWlanBgScan::NotConnected |
160 // CWlanBgScan::NotConnected |
178 // --------------------------------------------------------------------------- |
161 // --------------------------------------------------------------------------- |
179 // |
162 // |
180 void CWlanBgScan::NotConnected() |
163 void CWlanBgScan::NotConnected() |
181 { |
164 { |
182 DEBUG1( "CWlanBgScan::NotConnected() - current interval %us", GetInterval() ); |
165 DEBUG1( "CWlanBgScan::NotConnected() - current interval %us", GetBgInterval() ); |
183 |
166 |
184 if ( GetInterval() != KWlanBgScanIntervalNever ) |
167 if ( GetBgInterval() != KWlanBgScanIntervalNever ) |
185 { |
168 { |
186 DEBUG( "CWlanBgScan::NotConnected() - issue a new request with immediate expiry" ); |
169 DEBUG( "CWlanBgScan::NotConnected() - issue a new request with immediate expiry" ); |
187 iProvider.Scan( KWlanBgScanMaxDelayExpireImmediately ); |
170 iProvider.Scan( KWlanBgScanMaxDelayExpireImmediately ); |
188 } |
171 } |
189 } |
172 } |
397 // |
376 // |
398 CWlanBgScan::TRelation CWlanBgScan::TimeRelationToRange( const TTime& aTime, TUint aRangeStart, TUint aRangeEnd ) const |
377 CWlanBgScan::TRelation CWlanBgScan::TimeRelationToRange( const TTime& aTime, TUint aRangeStart, TUint aRangeEnd ) const |
399 { |
378 { |
400 #ifdef _DEBUG |
379 #ifdef _DEBUG |
401 TBuf<KWlanBgScanMaxDateTimeStrLen> dbgString; |
380 TBuf<KWlanBgScanMaxDateTimeStrLen> dbgString; |
402 TRAP_IGNORE( aTime.FormatL( dbgString, KWlanBgScanDateTimeFormat ) ); |
381 TRAP_IGNORE( aTime.FormatL( dbgString, KWlanBgScanDateTimeFormat2 ) ); |
403 DEBUG1( "CWlanBgScan::TimeRelationToRange() - time: %S", &dbgString ); |
382 DEBUG1( "CWlanBgScan::TimeRelationToRange() - time: %S", &dbgString ); |
404 #endif |
383 #endif |
405 |
|
406 TTime time( aTime ); |
|
407 |
|
408 TDateTime start_time( aTime.DateTime() ); |
|
409 start_time.SetHour( aRangeStart / KGetHours ); |
|
410 start_time.SetMinute( aRangeStart % KGetHours ); |
|
411 start_time.SetSecond( KZeroSeconds ); |
|
412 |
|
413 if( aRangeStart > aRangeEnd ) |
|
414 { |
|
415 DEBUG( "CWlanBgScan::TimeRelationToRange() - end time of range must to be tomorrow" ); |
|
416 if( time.DayNoInMonth() == ( time.DaysInMonth() - 1 ) ) |
|
417 { |
|
418 DEBUG( "CWlanBgScan::TimeRelationToRange() - last day of the month, move to next month" ); |
|
419 time += TTimeIntervalMonths( 1 ); |
|
420 DEBUG( "CWlanBgScan::TimeRelationToRange() - move to first day of the month" ); |
|
421 TDateTime new_time( time.DateTime() ); |
|
422 new_time.SetDay( 0 ); |
|
423 |
|
424 time = TTime( new_time ); |
|
425 } |
|
426 else |
|
427 { |
|
428 DEBUG( "CWlanBgScan::TimeRelationToRange() - add one day to end time" ); |
|
429 time += TTimeIntervalDays( KAddOneDay ); |
|
430 } |
|
431 } |
|
432 |
|
433 TDateTime end_time( time.DateTime() ); |
|
434 end_time.SetHour( aRangeEnd / KGetHours ); |
|
435 end_time.SetMinute( aRangeEnd % KGetHours ); |
|
436 end_time.SetSecond( KZeroSeconds ); |
|
437 |
384 |
438 #ifdef _DEBUG |
385 TDateTime dateTime( aTime.DateTime() ); |
439 TBuf<KWlanBgScanMaxDateTimeStrLen> rngStart, rngEnd; |
386 |
440 TRAP_IGNORE( TTime( start_time ).FormatL( rngStart, KWlanBgScanDateTimeFormat ) ); |
387 TUint timeToCheck = ( dateTime.Hour() * KGetHours ) + dateTime.Minute(); |
441 TRAP_IGNORE( TTime( end_time ).FormatL( rngEnd, KWlanBgScanDateTimeFormat ) ); |
388 |
442 DEBUG2( "CWlanBgScan::TimeRelationToRange() - range: %S - %S", &rngStart, &rngEnd ); |
389 DEBUG2( "CWlanBgScan::TimeRelationToRange() - range: %04u - %04u", aRangeStart, aRangeEnd ); |
443 #endif |
390 |
444 |
|
445 CWlanBgScan::TRelation relation( ESmaller ); |
391 CWlanBgScan::TRelation relation( ESmaller ); |
446 if( aTime < TTime( start_time ) ) |
392 |
447 { |
393 if( aRangeStart == aRangeEnd ) |
448 DEBUG( "CWlanBgScan::TimeRelationToRange() - returning: ESmaller" ); |
|
449 relation = ESmaller; |
|
450 } |
|
451 else if( aTime >= TTime( start_time ) && aTime < TTime( end_time ) ) |
|
452 { |
|
453 DEBUG( "CWlanBgScan::TimeRelationToRange() - returning: EInsideRange" ); |
|
454 relation = EInsideRange; |
|
455 } |
|
456 else |
|
457 { |
394 { |
458 DEBUG( "CWlanBgScan::TimeRelationToRange() - returning: EGreater" ); |
395 DEBUG( "CWlanBgScan::TimeRelationToRange() - returning: EGreater" ); |
459 relation = EGreater; |
396 relation = EGreater; |
|
397 } |
|
398 else if( aRangeStart > aRangeEnd ) |
|
399 { |
|
400 DEBUG( "CWlanBgScan::TimeRelationToRange() - range crosses the midnight" ); |
|
401 /** |
|
402 * As range crosses midnight, there is no way for the relation to be ESmaller. |
|
403 */ |
|
404 if( timeToCheck < aRangeEnd || timeToCheck >= aRangeStart ) |
|
405 { |
|
406 DEBUG( "CWlanBgScan::TimeRelationToRange() - returning: EInsideRange" ); |
|
407 relation = EInsideRange; |
|
408 } |
|
409 else |
|
410 { |
|
411 DEBUG( "CWlanBgScan::TimeRelationToRange() - returning: EGreater" ); |
|
412 relation = EGreater; |
|
413 } |
|
414 } |
|
415 else |
|
416 { |
|
417 if( timeToCheck < aRangeStart ) |
|
418 { |
|
419 DEBUG( "CWlanBgScan::TimeRelationToRange() - returning: ESmaller" ); |
|
420 relation = ESmaller; |
|
421 } |
|
422 else if( timeToCheck >= aRangeStart && timeToCheck < aRangeEnd ) |
|
423 { |
|
424 DEBUG( "CWlanBgScan::TimeRelationToRange() - returning: EInsideRange" ); |
|
425 relation = EInsideRange; |
|
426 } |
|
427 else |
|
428 { |
|
429 DEBUG( "CWlanBgScan::TimeRelationToRange() - returning: EGreater" ); |
|
430 relation = EGreater; |
|
431 } |
460 } |
432 } |
461 |
433 |
462 return relation; |
434 return relation; |
463 } |
435 } |
464 |
436 |
470 { |
442 { |
471 TUint32 interval( 0 ); |
443 TUint32 interval( 0 ); |
472 TTime currentTime; |
444 TTime currentTime; |
473 currentTime.HomeTime(); |
445 currentTime.HomeTime(); |
474 |
446 |
475 if( TimeRelationToRange( currentTime, iBgScanPeakStartTime, iBgScanPeakEndTime ) == CWlanBgScan::EInsideRange ) |
447 if( TimeRelationToRange( currentTime, iBgScanSettings.bgScanPeakStartTime, iBgScanSettings.bgScanPeakEndTime ) == CWlanBgScan::EInsideRange ) |
476 { |
448 { |
477 interval = iBgScanIntervalPeak; |
449 interval = iBgScanSettings.bgScanIntervalPeak; |
478 } |
450 } |
479 else |
451 else |
480 { |
452 { |
481 interval = iBgScanIntervalOffPeak; |
453 interval = iBgScanSettings.bgScanIntervalOffPeak; |
482 } |
454 } |
483 |
455 |
484 DEBUG1( "CWlanBgScan::CurrentAutoInterval() - current interval: %u", interval ); |
456 DEBUG1( "CWlanBgScan::CurrentAutoInterval() - current interval: %u", interval ); |
485 |
457 |
486 return interval; |
458 return interval; |
487 } |
459 } |
488 |
460 |
489 // --------------------------------------------------------------------------- |
461 // --------------------------------------------------------------------------- |
490 // CWlanBgScan::NextState |
462 // CWlanBgScan::StartAggressiveBgScan |
491 // --------------------------------------------------------------------------- |
463 // --------------------------------------------------------------------------- |
492 // |
464 // |
493 void CWlanBgScan::NextState( TUint32 aNewBgScanSetting ) |
465 void CWlanBgScan::StartAggressiveBgScan( TUint32& aInterval, TUint32& aTimeout ) |
494 { |
466 { |
495 DEBUG1( "CWlanBgScan::NextState() - aNewBgScanSetting %u", aNewBgScanSetting ); |
467 CWlanBgScanStates::StartAggressiveBgScan( aInterval, aTimeout ); |
496 |
468 } |
497 switch ( iBgScanState ) |
469 |
498 { |
470 // --------------------------------------------------------------------------- |
499 case EBgScanOff: |
471 // CWlanBgScan::OnTimeout |
500 { |
|
501 InStateOff( iBgScanState, aNewBgScanSetting ); |
|
502 break; |
|
503 } |
|
504 case EBgScanOn: |
|
505 { |
|
506 InStateOn( iBgScanState, aNewBgScanSetting ); |
|
507 break; |
|
508 } |
|
509 case EBgScanAuto: |
|
510 { |
|
511 InStateAuto( iBgScanState, aNewBgScanSetting ); |
|
512 break; |
|
513 } |
|
514 case EBgScanAutoAws: |
|
515 { |
|
516 InStateAutoAws( iBgScanState, aNewBgScanSetting ); |
|
517 break; |
|
518 } |
|
519 default: |
|
520 { |
|
521 ASSERT( 0 ); |
|
522 break; |
|
523 } |
|
524 } |
|
525 } |
|
526 |
|
527 // --------------------------------------------------------------------------- |
|
528 // CWlanBgScan::InStateOff |
|
529 // --------------------------------------------------------------------------- |
|
530 // |
|
531 void CWlanBgScan::InStateOff( TWlanBgScanState& aState, TUint32 aNewBgScanSetting ) |
|
532 { |
|
533 switch( aNewBgScanSetting ) |
|
534 { |
|
535 case KWlanBgScanIntervalNever: |
|
536 { |
|
537 DEBUG( "CWlanBgScan::InStateOff() - no change in the interval" ); |
|
538 aState = EBgScanOff; |
|
539 break; |
|
540 } |
|
541 case KWlanBgScanIntervalAutomatic: |
|
542 { |
|
543 if ( IsAwsPresent() ) |
|
544 { |
|
545 DEBUG( "CWlanBgScan::InStateOff() - state change Off to AutoAws" ); |
|
546 |
|
547 aState = EBgScanAutoAws; |
|
548 DEBUG( "CWlanBgScan::InStateOff() - calling SendOrQueueAwsCommand()" ); |
|
549 CWlanBgScanAwsComms::TAwsMessage msg = { CWlanBgScanAwsComms::EStart, 0 }; |
|
550 iAwsComms->SendOrQueueAwsCommand( msg ); |
|
551 DEBUG( "CWlanBgScan::InStateOff() - SendOrQueueAwsCommand() returned" ); |
|
552 } |
|
553 else |
|
554 { |
|
555 DEBUG( "CWlanBgScan::InStateOff() - state change Off to Auto" ); |
|
556 DEBUG( "CWlanBgScan::InStateOff() - * determine next interval change time and request callback" ); |
|
557 ScheduleAutoIntervalChange(); |
|
558 SetInterval( CurrentAutoInterval() ); |
|
559 if( GetInterval() != KWlanBgScanIntervalNever ) |
|
560 { |
|
561 DEBUG( "CWlanBgScan::InStateOff() - * cause immediate background scan" ); |
|
562 NotConnected(); |
|
563 } |
|
564 else |
|
565 { |
|
566 DEBUG( "CWlanBgScan::InStateOff() - Auto interval zero, background scanning is off" ); |
|
567 } |
|
568 aState = EBgScanAuto; |
|
569 } |
|
570 break; |
|
571 } |
|
572 default: |
|
573 { |
|
574 DEBUG1( "CWlanBgScan::InStateOff() - state change Off to On (interval: %u)", aNewBgScanSetting ); |
|
575 SetInterval( aNewBgScanSetting ); |
|
576 // cause immediate background scan |
|
577 NotConnected(); |
|
578 aState = EBgScanOn; |
|
579 } |
|
580 } |
|
581 } |
|
582 |
|
583 // --------------------------------------------------------------------------- |
|
584 // CWlanBgScan::InStateOn |
|
585 // --------------------------------------------------------------------------- |
|
586 // |
|
587 void CWlanBgScan::InStateOn( TWlanBgScanState& aState, TUint32 aNewBgScanSetting ) |
|
588 { |
|
589 switch( aNewBgScanSetting ) |
|
590 { |
|
591 case KWlanBgScanIntervalNever: |
|
592 { |
|
593 DEBUG( "CWlanBgScan::InStateOn() - state change On to Off" ); |
|
594 SetInterval( KWlanBgScanIntervalNever ); |
|
595 iProvider.CancelScan(); |
|
596 aState = EBgScanOff; |
|
597 break; |
|
598 } |
|
599 case KWlanBgScanIntervalAutomatic: |
|
600 { |
|
601 DEBUG( "CWlanBgScan::InStateOn() - state change On to Auto" ); |
|
602 SetInterval( KWlanBgScanIntervalNever ); |
|
603 iProvider.CancelScan(); |
|
604 if ( IsAwsPresent() ) |
|
605 { |
|
606 aState = EBgScanAutoAws; |
|
607 DEBUG( "CWlanBgScan::InStateOn() - calling SendOrQueueAwsCommand()" ); |
|
608 CWlanBgScanAwsComms::TAwsMessage msg = { CWlanBgScanAwsComms::EStart, 0 }; |
|
609 iAwsComms->SendOrQueueAwsCommand( msg ); |
|
610 DEBUG( "CWlanBgScan::InStateOn() - SendOrQueueAwsCommand() returned" ); |
|
611 } |
|
612 else |
|
613 { |
|
614 DEBUG( "CWlanBgScan::InStateOn() - * determine next interval change time and request callback" ); |
|
615 ScheduleAutoIntervalChange(); |
|
616 SetInterval( CurrentAutoInterval() ); |
|
617 if( GetInterval() != KWlanBgScanIntervalNever ) |
|
618 { |
|
619 DEBUG( "CWlanBgScan::InStateOn() - * cause immediate background scan" ); |
|
620 NotConnected(); |
|
621 } |
|
622 else |
|
623 { |
|
624 DEBUG( "CWlanBgScan::InStateOn() - Auto interval zero, background scanning is off" ); |
|
625 } |
|
626 aState = EBgScanAuto; |
|
627 } |
|
628 break; |
|
629 } |
|
630 default: |
|
631 { |
|
632 DEBUG( "CWlanBgScan::InStateOn() - state change On to On" ); |
|
633 if ( GetInterval() == aNewBgScanSetting ) |
|
634 { |
|
635 DEBUG( "CWlanBgScan::InStateOn() - no change in the interval" ); |
|
636 } |
|
637 else if ( GetInterval() > aNewBgScanSetting ) |
|
638 { |
|
639 DEBUG( "CWlanBgScan::InStateOn() - current interval greater than the new interval" ); |
|
640 DEBUG( "CWlanBgScan::InStateOn() - * cancel scan and cause immediate background scan" ); |
|
641 iProvider.CancelScan(); |
|
642 SetInterval( aNewBgScanSetting ); |
|
643 NotConnected(); |
|
644 } |
|
645 else |
|
646 { |
|
647 DEBUG( "CWlanBgScan::InStateOn() - current interval smaller than the new interval" ); |
|
648 DEBUG( "CWlanBgScan::InStateOn() - * cancel scan and issue new with interval as expiry" ); |
|
649 iProvider.CancelScan(); |
|
650 SetInterval( aNewBgScanSetting ); |
|
651 ScanComplete(); |
|
652 } |
|
653 aState = EBgScanOn; |
|
654 } |
|
655 } |
|
656 } |
|
657 |
|
658 // --------------------------------------------------------------------------- |
|
659 // CWlanBgScan::InStateAuto |
|
660 // --------------------------------------------------------------------------- |
|
661 // |
|
662 void CWlanBgScan::InStateAuto( TWlanBgScanState& aState, TUint32 aNewBgScanSetting ) |
|
663 { |
|
664 switch( aNewBgScanSetting ) |
|
665 { |
|
666 case KWlanBgScanIntervalNever: |
|
667 { |
|
668 DEBUG( "CWlanBgScan::InStateAuto() - state change Auto to Off" ); |
|
669 SetInterval( KWlanBgScanIntervalNever ); |
|
670 iTimerServices.StopTimer( iIntervalChangeRequestId ); |
|
671 iIntervalChangeRequestId = 0; |
|
672 iProvider.CancelScan(); |
|
673 aState = EBgScanOff; |
|
674 break; |
|
675 } |
|
676 case KWlanBgScanIntervalAutomatic: |
|
677 { |
|
678 DEBUG( "CWlanBgScan::InStateAuto() - state still Auto" ); |
|
679 |
|
680 ScheduleAutoIntervalChange(); |
|
681 |
|
682 TUint32 currentInterval = GetInterval(); |
|
683 |
|
684 TUint32 autoInterval = CurrentAutoInterval(); |
|
685 |
|
686 if ( autoInterval == KWlanBgScanIntervalNever ) |
|
687 { |
|
688 DEBUG( "CWlanBgScan::InStateAuto() - Auto interval zero, background scanning is off" ); |
|
689 DEBUG( "CWlanBgScan::InStateAuto() - * cancel scan" ); |
|
690 iProvider.CancelScan(); |
|
691 SetInterval( autoInterval ); |
|
692 } |
|
693 else if ( currentInterval == autoInterval ) |
|
694 { |
|
695 DEBUG( "CWlanBgScan::InStateAuto() - no change in the Auto interval" ); |
|
696 } |
|
697 else if ( currentInterval > autoInterval ) |
|
698 { |
|
699 DEBUG( "CWlanBgScan::InStateAuto() - current Auto interval greater than the new Auto interval" ); |
|
700 DEBUG( "CWlanBgScan::InStateAuto() - * cancel scan and issue new with immediate expiry" ); |
|
701 iProvider.CancelScan(); |
|
702 SetInterval( autoInterval ); |
|
703 NotConnected(); |
|
704 } |
|
705 else |
|
706 { |
|
707 DEBUG( "CWlanBgScan::InStateAuto() - current Auto interval smaller than the new Auto interval" ); |
|
708 DEBUG( "CWlanBgScan::InStateAuto() - * cancel scan and issue new with interval expiry" ); |
|
709 iProvider.CancelScan(); |
|
710 SetInterval( autoInterval ); |
|
711 ScanComplete(); |
|
712 } |
|
713 |
|
714 aState = EBgScanAuto; |
|
715 break; |
|
716 } |
|
717 default: |
|
718 { |
|
719 DEBUG( "CWlanBgScan::InStateAuto() - state change Auto to On" ); |
|
720 SetInterval( aNewBgScanSetting ); |
|
721 iTimerServices.StopTimer( iIntervalChangeRequestId ); |
|
722 iIntervalChangeRequestId = 0; |
|
723 // need to issue new scan request as it is possible that currently there is |
|
724 // no scan requested |
|
725 iProvider.CancelScan(); |
|
726 NotConnected(); |
|
727 aState = EBgScanOn; |
|
728 } |
|
729 } |
|
730 } |
|
731 |
|
732 // --------------------------------------------------------------------------- |
|
733 // CWlanBgScan::InStateAutoAws |
|
734 // --------------------------------------------------------------------------- |
|
735 // |
|
736 void CWlanBgScan::InStateAutoAws( TWlanBgScanState& aState, TUint32 aNewBgScanSetting ) |
|
737 { |
|
738 switch( aNewBgScanSetting ) |
|
739 { |
|
740 case KWlanBgScanIntervalNever: |
|
741 { |
|
742 DEBUG( "CWlanBgScan::InStateAutoAws() - state change Auto to Off" ); |
|
743 SetInterval( KWlanBgScanIntervalNever ); |
|
744 aState = EBgScanOff; |
|
745 DEBUG( "CWlanBgScan::InStateAutoAws() - calling SendOrQueueAwsCommand()" ); |
|
746 CWlanBgScanAwsComms::TAwsMessage msg = { CWlanBgScanAwsComms::EStop, 0 }; |
|
747 iAwsComms->SendOrQueueAwsCommand( msg ); |
|
748 DEBUG( "CWlanBgScan::InStateAutoAws() - SendOrQueueAwsCommand() returned" ); |
|
749 iProvider.CancelScan(); |
|
750 break; |
|
751 } |
|
752 case KWlanBgScanIntervalAutomatic: |
|
753 { |
|
754 DEBUG( "CWlanBgScan::InStateAutoAws() - no change in the interval" ); |
|
755 aState = EBgScanAutoAws; |
|
756 break; |
|
757 } |
|
758 default: |
|
759 { |
|
760 DEBUG( "CWlanBgScan::InStateAutoAws() - state change Auto to On" ); |
|
761 SetInterval( aNewBgScanSetting ); |
|
762 aState = EBgScanOn; |
|
763 // need to issue new scan request as it is possible that currently there is |
|
764 // no scan requested |
|
765 DEBUG( "CWlanBgScan::InStateAutoAws() - calling SendAwsCommand()" ); |
|
766 CWlanBgScanAwsComms::TAwsMessage msg = { CWlanBgScanAwsComms::EStop, 0 }; |
|
767 iAwsComms->SendOrQueueAwsCommand( msg ); |
|
768 DEBUG( "CWlanBgScan::InStateAutoAws() - SendAwsCommand() returned" ); |
|
769 iProvider.CancelScan(); |
|
770 NotConnected(); |
|
771 } |
|
772 } |
|
773 } |
|
774 |
|
775 // --------------------------------------------------------------------------- |
|
776 // CWlanBgScan::Timeout |
|
777 // --------------------------------------------------------------------------- |
472 // --------------------------------------------------------------------------- |
778 // |
473 // |
779 void CWlanBgScan::OnTimeout() |
474 void CWlanBgScan::OnTimeout() |
780 { |
475 { |
781 DEBUG( "CWlanBgScan::OnTimeout()" ); |
476 DEBUG( "CWlanBgScan::OnTimeout()" ); |
782 |
477 |
783 // by design, OnTimeout should only happen |
478 NextState( CWlanBgScanStates::EBgScanEventIntervalChanged ); |
784 // in Auto state |
|
785 ASSERT( iBgScanState == EBgScanAuto ); |
|
786 |
|
787 NextState( KWlanBgScanIntervalAutomatic ); |
|
788 |
479 |
789 } |
480 } |
790 |
481 |
791 // --------------------------------------------------------------------------- |
482 // --------------------------------------------------------------------------- |
792 // CWlanBgScan::DoSetInterval |
483 // CWlanBgScan::DoSetInterval |
793 // --------------------------------------------------------------------------- |
484 // --------------------------------------------------------------------------- |
794 // |
485 // |
795 void CWlanBgScan::DoSetInterval( TUint32 aNewInterval ) |
486 void CWlanBgScan::DoSetInterval( TUint32 aNewInterval ) |
796 { |
487 { |
797 DEBUG1( "CWlanBgScan::DoSetInterval( aNewInterval: %u )", aNewInterval ); |
488 DEBUG1( "CWlanBgScan::DoSetInterval( aNewInterval: %u )", aNewInterval ); |
798 |
|
799 if( iBgScanState != EBgScanAutoAws ) |
|
800 { |
|
801 DEBUG( "CWlanBgScan::DoSetInterval() - state not AutoAws, ignoring request" ); |
|
802 return; |
|
803 } |
|
804 |
|
805 TUint32 currentInterval( GetInterval() ); |
|
806 |
489 |
807 if ( ( currentInterval == 0 ) && ( aNewInterval != 0 ) ) |
490 SetAutoInterval( aNewInterval ); |
808 { |
491 DEBUG( "CWlanBgScan::DoSetInterval() - interval stored, giving event to state machine" ); |
809 DEBUG( "CWlanBgScan::DoSetInterval() - current interval is zero and new interval is non-zero" ); |
492 |
810 DEBUG( "CWlanBgScan::DoSetInterval() - cancel scan and issue new with immediate expiry" ); |
493 NextState( CWlanBgScanStates::EBgScanEventAwsIntervalChanged ); |
811 iProvider.CancelScan(); |
494 |
812 SetInterval( aNewInterval ); |
495 } |
813 NotConnected(); |
496 |
814 } |
497 // --------------------------------------------------------------------------- |
815 else if ( currentInterval == aNewInterval ) |
498 // CWlanBgScan::AwsPresence |
816 { |
499 // -------------------------------------------------------------------------- |
817 DEBUG( "CWlanBgScan::DoSetInterval() - no change in the interval" ); |
500 // |
818 } |
501 CWlanBgScan::TAwsPresence CWlanBgScan::AwsPresence() |
819 else if ( currentInterval > aNewInterval ) |
502 { |
820 { |
503 CWlanBgScan::TAwsPresence ret( CWlanBgScan::EAwsPresent ); |
821 // if current interval greater than new interval -> cancel scan and |
504 |
822 // issue new with immediate expiry |
505 // If ( ( iAwsOk == EFalse ) And ( iAwsComms == NULL ) ) -> Return EAwsNotPresent |
823 DEBUG( "CWlanBgScan::DoSetInterval() - current interval greater than the new interval" ); |
506 // If ( ( iAwsOk == EFalse ) And ( iAwsComms != NULL ) ) -> Return EAwsStarting |
824 DEBUG( "CWlanBgScan::DoSetInterval() - cancel scan and issue new with immediate expiry" ); |
507 // Otherwise -> return EAwsPresent |
825 iProvider.CancelScan(); |
508 |
826 SetInterval( aNewInterval ); |
509 if( iAwsOk == EFalse && iAwsComms == NULL ) |
827 NotConnected(); |
510 { |
828 } |
511 ret = CWlanBgScan::EAwsNotPresent; |
|
512 } |
|
513 if( iAwsOk == EFalse && iAwsComms != NULL ) |
|
514 { |
|
515 ret = CWlanBgScan::EAwsStarting; |
|
516 } |
|
517 |
|
518 DEBUG1( "CWlanBgScan::AwsStatus() - returning %i", ret ); |
|
519 |
|
520 return ret; |
|
521 } |
|
522 |
|
523 // --------------------------------------------------------------------------- |
|
524 // CWlanBgScan::AwsStartupComplete |
|
525 // -------------------------------------------------------------------------- |
|
526 // |
|
527 void CWlanBgScan::AwsStartupComplete( TInt aStatus ) |
|
528 { |
|
529 DEBUG1( "CWlanBgScan::AwsStartupComplete( aStatus: %d )", aStatus ); |
|
530 |
|
531 SetAwsStartupStatus( aStatus ); |
|
532 |
|
533 if( aStatus == KErrNone ) |
|
534 { |
|
535 // AWS is ok |
|
536 iAwsOk = ETrue; |
|
537 } |
|
538 #ifdef _DEBUG |
829 else |
539 else |
830 { |
540 { |
831 DEBUG( "CWlanBgScan::DoSetInterval() - current interval smaller than the new interval" ); |
541 DEBUG( "CWlanBgScan::AwsStartupComplete() - error: AWS startup completed with error status, AWS not in use" ); |
832 DEBUG( "CWlanBgScan::DoSetInterval() - take new interval into use after currently pending scan is completed" ); |
542 } |
833 SetInterval( aNewInterval ); |
543 #endif |
834 } |
544 |
835 |
545 NextState( CWlanBgScanStates::EBgScanEventAwsStartupComplete ); |
836 } |
546 |
837 |
547 } |
838 // --------------------------------------------------------------------------- |
548 |
839 // CWlanBgScan::IsAwsPresent |
549 // --------------------------------------------------------------------------- |
|
550 // CWlanBgScan::AwsCommandComplete |
840 // -------------------------------------------------------------------------- |
551 // -------------------------------------------------------------------------- |
841 // |
552 // |
842 TBool CWlanBgScan::IsAwsPresent() |
553 void CWlanBgScan::AwsCommandComplete( MWlanBgScanAwsComms::TAwsCommand& aCommand, TInt aStatus ) |
843 { |
554 { |
844 TBool ret( ETrue ); |
555 DEBUG2( "CWlanBgScan::AwsCommandComplete( aCommand: %d, aStatus: %d )", aCommand, aStatus ); |
845 |
556 |
846 if( iAwsComms == NULL || !iAwsComms->IsAwsPresent() ) |
557 SetAwsCmdStatus( aCommand, aStatus ); |
847 { |
558 |
848 ret = EFalse; |
559 NextState( CWlanBgScanStates::EBgScanEventAwsCmdComplete ); |
849 } |
560 |
850 |
561 } |
851 DEBUG1( "CWlanBgScan::IsAwsPresent() - returning %i", ret ); |
562 |
852 |
563 // --------------------------------------------------------------------------- |
853 return ret; |
564 // CWlanBgScan::AwsCommand |
854 } |
565 // -------------------------------------------------------------------------- |
|
566 // |
|
567 void CWlanBgScan::AwsCommand( MWlanBgScanAwsComms::TAwsMessage& aCommand ) |
|
568 { |
|
569 DEBUG( "CWlanBgScan::AwsCommand() - calling SendOrQueueAwsCommand()" ); |
|
570 iAwsComms->SendOrQueueAwsCommand( aCommand ); |
|
571 |
|
572 } |
|
573 |