|
1 /* |
|
2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of the License "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: This class implements WLAN background scan logic. |
|
15 * |
|
16 */ |
|
17 |
|
18 /* |
|
19 * %version: 12 % |
|
20 */ |
|
21 |
|
22 #include <e32base.h> |
|
23 #include <e32const.h> |
|
24 |
|
25 #include "wlanscanproviderinterface.h" |
|
26 #include "awsinterface.h" |
|
27 #include "awsenginebase.h" |
|
28 #include "wlancbwaiter.h" |
|
29 #include "wlanbgscanawscomms.h" |
|
30 #include "wlanbgscan.h" |
|
31 #include "wlandevicesettings.h" // default values in case invalid data is passed in NotifyChangedSettings |
|
32 #include "am_debug.h" |
|
33 |
|
34 /** |
|
35 * One day to be added to TTime. |
|
36 */ |
|
37 const TInt KAddOneDay = 1; |
|
38 |
|
39 /** |
|
40 * Get hours from CenRep variable. |
|
41 */ |
|
42 const TInt KGetHours = 100; |
|
43 |
|
44 /** |
|
45 * Zero seconds. |
|
46 */ |
|
47 const TInt KZeroSeconds = 0; |
|
48 |
|
49 /** |
|
50 * Last minute of a day. |
|
51 */ |
|
52 const TInt KWlanBgScanTwentyThreeFiftyNineOclock = 2359; |
|
53 |
|
54 /** |
|
55 * Maximun interval for background scan. |
|
56 */ |
|
57 const TInt KWlanBgScanMaxInterval = 1800; |
|
58 |
|
59 #ifdef _DEBUG |
|
60 /** |
|
61 * Formatting of date time debug string. |
|
62 */ |
|
63 _LIT( KWlanBgScanDateTimeFormat, "%F %*E %*N %D %H:%T:%S" ); |
|
64 |
|
65 /** |
|
66 * Maximun length for date time debug string. |
|
67 */ |
|
68 const TInt KWlanBgScanMaxDateTimeStrLen = 50; |
|
69 #endif |
|
70 |
|
71 // ======== MEMBER FUNCTIONS ======== |
|
72 |
|
73 // --------------------------------------------------------------------------- |
|
74 // CWlanBgScan::CWlanBgScan |
|
75 // --------------------------------------------------------------------------- |
|
76 // |
|
77 CWlanBgScan::CWlanBgScan( MWlanScanResultProvider& aProvider, CWlanTimerServices& aTimerServices ) : |
|
78 iProvider ( aProvider ), |
|
79 iCurrentBgScanInterval( 0 ), |
|
80 iAwsComms( NULL ), |
|
81 iBgScanState( EBgScanOff ), |
|
82 iAutoPeriod( EAutoPeriodNone ), |
|
83 iTimerServices( aTimerServices ), |
|
84 iIntervalChangeRequestId( 0 ), |
|
85 iBgScanPeakStartTime( 0 ), |
|
86 iBgScanPeakEndTime( 0 ), |
|
87 iBgScanIntervalPeak( 0 ), |
|
88 iBgScanIntervalOffPeak( 0 ) |
|
89 { |
|
90 DEBUG( "CWlanBgScan::CWlanBgScan()" ); |
|
91 } |
|
92 |
|
93 // --------------------------------------------------------------------------- |
|
94 // CWlanBgScan::ConstructL |
|
95 // --------------------------------------------------------------------------- |
|
96 // |
|
97 void CWlanBgScan::ConstructL() |
|
98 { |
|
99 DEBUG( "CWlanBgScan::ConstructL()" ); |
|
100 |
|
101 // create AWS comms interface |
|
102 TRAPD( err, iAwsComms = CWlanBgScanAwsComms::NewL( *this ) ); |
|
103 if( err != KErrNone ) |
|
104 { |
|
105 if( iAwsComms ) |
|
106 { |
|
107 delete iAwsComms; |
|
108 iAwsComms = NULL; |
|
109 } |
|
110 DEBUG1( "CWlanBgScan::ConstructL() - AWS comms creation failed with code %i", err ); |
|
111 } |
|
112 else |
|
113 { |
|
114 DEBUG( "CWlanBgScan::ConstructL() - AWS comms creation successful" ); |
|
115 } |
|
116 |
|
117 DEBUG( "CWlanBgScan::ConstructL() - done" ); |
|
118 } |
|
119 |
|
120 // --------------------------------------------------------------------------- |
|
121 // CWlanBgScan::NewL |
|
122 // --------------------------------------------------------------------------- |
|
123 // |
|
124 CWlanBgScan* CWlanBgScan::NewL( MWlanScanResultProvider& aProvider, CWlanTimerServices& aTimerServices ) |
|
125 { |
|
126 DEBUG( "CWlanBgScan::NewL()" ); |
|
127 CWlanBgScan* self = new ( ELeave ) CWlanBgScan( aProvider, aTimerServices ); |
|
128 CleanupStack::PushL( self ); |
|
129 self->ConstructL(); |
|
130 CleanupStack::Pop( self ); |
|
131 return self; |
|
132 } |
|
133 |
|
134 // --------------------------------------------------------------------------- |
|
135 // CWlanBgScan::~CWlanBgScan |
|
136 // --------------------------------------------------------------------------- |
|
137 // |
|
138 CWlanBgScan::~CWlanBgScan() |
|
139 { |
|
140 DEBUG( "CWlanBgScan::CWlanBgScan()" ); |
|
141 } |
|
142 |
|
143 // --------------------------------------------------------------------------- |
|
144 // From class MWlanBgScanProvider. |
|
145 // CWlanBgScan::ScanComplete |
|
146 // --------------------------------------------------------------------------- |
|
147 // |
|
148 void CWlanBgScan::ScanComplete() |
|
149 { |
|
150 DEBUG1( "CWlanBgScan::ScanComplete() - current interval %us", GetInterval() ); |
|
151 |
|
152 if ( GetInterval() != KWlanBgScanIntervalNever ) |
|
153 { |
|
154 DEBUG1( "CWlanBgScan::ScanComplete() - issue a new request with %us as expiry", GetInterval() ); |
|
155 iProvider.Scan( GetInterval() ); |
|
156 } |
|
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 } |
|
174 |
|
175 // --------------------------------------------------------------------------- |
|
176 // From class MWlanBgScanProvider. |
|
177 // CWlanBgScan::NotConnected |
|
178 // --------------------------------------------------------------------------- |
|
179 // |
|
180 void CWlanBgScan::NotConnected() |
|
181 { |
|
182 DEBUG1( "CWlanBgScan::NotConnected() - current interval %us", GetInterval() ); |
|
183 |
|
184 if ( GetInterval() != KWlanBgScanIntervalNever ) |
|
185 { |
|
186 DEBUG( "CWlanBgScan::NotConnected() - issue a new request with immediate expiry" ); |
|
187 iProvider.Scan( KWlanBgScanMaxDelayExpireImmediately ); |
|
188 } |
|
189 } |
|
190 |
|
191 // --------------------------------------------------------------------------- |
|
192 // From class MWlanBgScanProvider. |
|
193 // CWlanBgScan::IsBgScanEnabled |
|
194 // --------------------------------------------------------------------------- |
|
195 // |
|
196 TBool CWlanBgScan::IsBgScanEnabled() |
|
197 { |
|
198 // If ( interval != never ) -> Return True |
|
199 // Otherwise -> return False |
|
200 DEBUG1( "CWlanBgScan::IsBgScanEnabled() - returning %u", |
|
201 ( GetInterval() != KWlanBgScanIntervalNever ) ? 1 : 0 ); |
|
202 |
|
203 return ( GetInterval() != KWlanBgScanIntervalNever ); |
|
204 } |
|
205 |
|
206 // --------------------------------------------------------------------------- |
|
207 // From class MWlanBgScanProvider. |
|
208 // CWlanBgScan::NotifyChangedSettings |
|
209 // --------------------------------------------------------------------------- |
|
210 // |
|
211 void CWlanBgScan::NotifyChangedSettings( MWlanBgScanProvider::TWlanBgScanSettings& aSettings ) |
|
212 { |
|
213 DEBUG6( "CWlanBgScan::NotifyChangedSettings( interval: %u, psm srv mode: %u, peak start: %04u, peak end: %04u, peak: %u, off-peak: %u )", |
|
214 aSettings.backgroundScanInterval, |
|
215 aSettings.psmServerMode, |
|
216 aSettings.bgScanPeakStartTime, |
|
217 aSettings.bgScanPeakEndTime, |
|
218 aSettings.bgScanIntervalPeak, |
|
219 aSettings.bgScanIntervalOffPeak); |
|
220 |
|
221 MWlanBgScanProvider::TWlanBgScanSettings settingsToUse; |
|
222 CheckSettings( settingsToUse, aSettings ); |
|
223 |
|
224 iBgScanPeakStartTime = settingsToUse.bgScanPeakStartTime; |
|
225 iBgScanPeakEndTime = settingsToUse.bgScanPeakEndTime; |
|
226 iBgScanIntervalPeak = settingsToUse.bgScanIntervalPeak; |
|
227 iBgScanIntervalOffPeak = settingsToUse.bgScanIntervalOffPeak; |
|
228 |
|
229 IntervalChanged( settingsToUse.backgroundScanInterval ); |
|
230 |
|
231 if( IsAwsPresent() ) |
|
232 { |
|
233 CWlanBgScanAwsComms::TAwsMessage msg = { CWlanBgScanAwsComms::ESetPowerSaveMode, aSettings.psmServerMode }; |
|
234 iAwsComms->SendOrQueueAwsCommand( msg ); |
|
235 } |
|
236 } |
|
237 |
|
238 // --------------------------------------------------------------------------- |
|
239 // CWlanBgScan::CheckSettings |
|
240 // --------------------------------------------------------------------------- |
|
241 // |
|
242 void CWlanBgScan::CheckSettings( |
|
243 MWlanBgScanProvider::TWlanBgScanSettings& aSettingsToUse, // [OUT] |
|
244 const MWlanBgScanProvider::TWlanBgScanSettings& aProposedSettings ) const // [IN] |
|
245 { |
|
246 aSettingsToUse = aProposedSettings; |
|
247 |
|
248 if( aSettingsToUse.bgScanPeakStartTime > KWlanBgScanTwentyThreeFiftyNineOclock || |
|
249 aSettingsToUse.bgScanPeakEndTime > KWlanBgScanTwentyThreeFiftyNineOclock ) |
|
250 { |
|
251 DEBUG2( "CWlanBgScan::CheckSettings() - peak start or end invalid, using default values (start %u, end %u)", |
|
252 KWlanDefaultBgScanPeakPeriodStart, |
|
253 KWlanDefaultBgScanPeakPeriodEnd ); |
|
254 aSettingsToUse.bgScanPeakStartTime = KWlanDefaultBgScanPeakPeriodStart; |
|
255 aSettingsToUse.bgScanPeakEndTime = KWlanDefaultBgScanPeakPeriodEnd; |
|
256 } |
|
257 if( aSettingsToUse.bgScanIntervalPeak > KWlanBgScanMaxInterval ) |
|
258 { |
|
259 DEBUG1( "CWlanBgScan::CheckSettings() - peak interval invalid, using default value %u", |
|
260 KWlanDefaultBgScanIntervalPeakPeriod ); |
|
261 aSettingsToUse.bgScanIntervalPeak = KWlanDefaultBgScanIntervalPeakPeriod; |
|
262 } |
|
263 if( aSettingsToUse.bgScanIntervalOffPeak > KWlanBgScanMaxInterval ) |
|
264 { |
|
265 DEBUG1( "CWlanBgScan::CheckSettings() - off-peak interval invalid, using default value %u", |
|
266 KWlanDefaultBgScanIntervalOffPeakPeriod ); |
|
267 aSettingsToUse.bgScanIntervalOffPeak = KWlanDefaultBgScanIntervalOffPeakPeriod; |
|
268 } |
|
269 } |
|
270 |
|
271 // --------------------------------------------------------------------------- |
|
272 // CWlanBgScan::GetInterval |
|
273 // --------------------------------------------------------------------------- |
|
274 // |
|
275 TUint32 CWlanBgScan::GetInterval() |
|
276 { |
|
277 return iCurrentBgScanInterval; |
|
278 } |
|
279 |
|
280 // --------------------------------------------------------------------------- |
|
281 // CWlanBgScan::SetInterval |
|
282 // --------------------------------------------------------------------------- |
|
283 // |
|
284 void CWlanBgScan::SetInterval( TUint32 aInterval ) |
|
285 { |
|
286 iCurrentBgScanInterval = aInterval; |
|
287 } |
|
288 |
|
289 // --------------------------------------------------------------------------- |
|
290 // CWlanBgScan::IsIntervalChangeNeeded |
|
291 // --------------------------------------------------------------------------- |
|
292 // |
|
293 TBool CWlanBgScan::IsIntervalChangeNeeded() |
|
294 { |
|
295 TBool ret( ETrue ); |
|
296 |
|
297 // no need to change interval if both peak and off-peak intervals are the same |
|
298 if( iBgScanPeakStartTime == iBgScanPeakEndTime ) |
|
299 { |
|
300 ret = EFalse; |
|
301 } |
|
302 |
|
303 DEBUG1( "CWlanBgScan::IsIntervalChangeNeeded() - returning %d", ret ); |
|
304 |
|
305 return ret; |
|
306 } |
|
307 |
|
308 // --------------------------------------------------------------------------- |
|
309 // CWlanBgScan::ScheduleAutoIntervalChange |
|
310 // --------------------------------------------------------------------------- |
|
311 // |
|
312 void CWlanBgScan::ScheduleAutoIntervalChange() |
|
313 { |
|
314 DEBUG( "CWlanBgScan::ScheduleAutoIntervalChange()" ); |
|
315 |
|
316 iTimerServices.StopTimer( iIntervalChangeRequestId ); |
|
317 |
|
318 if( IsIntervalChangeNeeded() ) |
|
319 { |
|
320 TTime intervalChangeAt = AutoIntervalChangeAt(); |
|
321 |
|
322 if( KErrNone != iTimerServices.StartTimer( iIntervalChangeRequestId, intervalChangeAt, *this ) ) |
|
323 { |
|
324 DEBUG( "CWlanBgScan::ScheduleAutoIntervalChange() - error: requesting timeout failed, peak <-> off-peak interval will not be changed" ); |
|
325 } |
|
326 } |
|
327 else |
|
328 { |
|
329 DEBUG( "CWlanBgScan::ScheduleAutoIntervalChange() - peak <-> off-peak interval change not needed" ); |
|
330 } |
|
331 |
|
332 DEBUG( "CWlanBgScan::ScheduleAutoIntervalChange() - returning" ); |
|
333 |
|
334 } |
|
335 |
|
336 // --------------------------------------------------------------------------- |
|
337 // CWlanBgScan::AutoIntervalChangeAt |
|
338 // --------------------------------------------------------------------------- |
|
339 // |
|
340 TTime CWlanBgScan::AutoIntervalChangeAt() |
|
341 { |
|
342 TTime currentTime; |
|
343 currentTime.HomeTime(); |
|
344 TDateTime change_time( currentTime.DateTime() ); |
|
345 |
|
346 switch( TimeRelationToRange( currentTime, iBgScanPeakStartTime, iBgScanPeakEndTime ) ) |
|
347 { |
|
348 case ESmaller: |
|
349 { |
|
350 change_time.SetHour( iBgScanPeakStartTime / KGetHours ); |
|
351 change_time.SetMinute( iBgScanPeakStartTime % KGetHours ); |
|
352 change_time.SetSecond( KZeroSeconds ); |
|
353 currentTime = change_time; |
|
354 break; |
|
355 } |
|
356 case EInsideRange: |
|
357 { |
|
358 change_time.SetHour( iBgScanPeakEndTime / KGetHours ); |
|
359 change_time.SetMinute( iBgScanPeakEndTime % KGetHours ); |
|
360 change_time.SetSecond( KZeroSeconds ); |
|
361 currentTime = change_time; |
|
362 if( iBgScanPeakStartTime > iBgScanPeakEndTime ) |
|
363 { |
|
364 DEBUG( "CWlanBgScan::AutoIntervalChangeAt() - peak end happens tomorrow" ); |
|
365 currentTime += TTimeIntervalDays( KAddOneDay ); |
|
366 } |
|
367 else |
|
368 { |
|
369 DEBUG( "CWlanBgScan::AutoIntervalChangeAt() - peak end happens today" ); |
|
370 } |
|
371 break; |
|
372 } |
|
373 case EGreater: |
|
374 { |
|
375 change_time.SetHour( iBgScanPeakStartTime / KGetHours ); |
|
376 change_time.SetMinute( iBgScanPeakStartTime % KGetHours ); |
|
377 change_time.SetSecond( KZeroSeconds ); |
|
378 currentTime = change_time; |
|
379 currentTime += TTimeIntervalDays( KAddOneDay ); |
|
380 break; |
|
381 } |
|
382 } |
|
383 |
|
384 #ifdef _DEBUG |
|
385 change_time = currentTime.DateTime(); |
|
386 TBuf<KWlanBgScanMaxDateTimeStrLen> dbgString; |
|
387 TRAP_IGNORE( currentTime.FormatL( dbgString, KWlanBgScanDateTimeFormat ) ); |
|
388 DEBUG1( "CWlanBgScan::AutoIntervalChangeAt() - interval change to occur: %S", &dbgString ); |
|
389 #endif |
|
390 |
|
391 return currentTime; |
|
392 } |
|
393 |
|
394 // --------------------------------------------------------------------------- |
|
395 // CWlanBgScan::TimeRelationToRange |
|
396 // --------------------------------------------------------------------------- |
|
397 // |
|
398 CWlanBgScan::TRelation CWlanBgScan::TimeRelationToRange( const TTime& aTime, TUint aRangeStart, TUint aRangeEnd ) const |
|
399 { |
|
400 #ifdef _DEBUG |
|
401 TBuf<KWlanBgScanMaxDateTimeStrLen> dbgString; |
|
402 TRAP_IGNORE( aTime.FormatL( dbgString, KWlanBgScanDateTimeFormat ) ); |
|
403 DEBUG1( "CWlanBgScan::TimeRelationToRange() - time: %S", &dbgString ); |
|
404 #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 |
|
438 #ifdef _DEBUG |
|
439 TBuf<KWlanBgScanMaxDateTimeStrLen> rngStart, rngEnd; |
|
440 TRAP_IGNORE( TTime( start_time ).FormatL( rngStart, KWlanBgScanDateTimeFormat ) ); |
|
441 TRAP_IGNORE( TTime( end_time ).FormatL( rngEnd, KWlanBgScanDateTimeFormat ) ); |
|
442 DEBUG2( "CWlanBgScan::TimeRelationToRange() - range: %S - %S", &rngStart, &rngEnd ); |
|
443 #endif |
|
444 |
|
445 CWlanBgScan::TRelation relation( ESmaller ); |
|
446 if( aTime < TTime( start_time ) ) |
|
447 { |
|
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 { |
|
458 DEBUG( "CWlanBgScan::TimeRelationToRange() - returning: EGreater" ); |
|
459 relation = EGreater; |
|
460 } |
|
461 |
|
462 return relation; |
|
463 } |
|
464 |
|
465 // --------------------------------------------------------------------------- |
|
466 // CWlanBgScan::CurrentAutoInterval |
|
467 // --------------------------------------------------------------------------- |
|
468 // |
|
469 TUint32 CWlanBgScan::CurrentAutoInterval() |
|
470 { |
|
471 TUint32 interval( 0 ); |
|
472 TTime currentTime; |
|
473 currentTime.HomeTime(); |
|
474 |
|
475 if( TimeRelationToRange( currentTime, iBgScanPeakStartTime, iBgScanPeakEndTime ) == CWlanBgScan::EInsideRange ) |
|
476 { |
|
477 interval = iBgScanIntervalPeak; |
|
478 } |
|
479 else |
|
480 { |
|
481 interval = iBgScanIntervalOffPeak; |
|
482 } |
|
483 |
|
484 DEBUG1( "CWlanBgScan::CurrentAutoInterval() - current interval: %u", interval ); |
|
485 |
|
486 return interval; |
|
487 } |
|
488 |
|
489 // --------------------------------------------------------------------------- |
|
490 // CWlanBgScan::NextState |
|
491 // --------------------------------------------------------------------------- |
|
492 // |
|
493 void CWlanBgScan::NextState( TUint32 aNewBgScanSetting ) |
|
494 { |
|
495 DEBUG1( "CWlanBgScan::NextState() - aNewBgScanSetting %u", aNewBgScanSetting ); |
|
496 |
|
497 switch ( iBgScanState ) |
|
498 { |
|
499 case EBgScanOff: |
|
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 // --------------------------------------------------------------------------- |
|
778 // |
|
779 void CWlanBgScan::OnTimeout() |
|
780 { |
|
781 DEBUG( "CWlanBgScan::OnTimeout()" ); |
|
782 |
|
783 // by design, OnTimeout should only happen |
|
784 // in Auto state |
|
785 ASSERT( iBgScanState == EBgScanAuto ); |
|
786 |
|
787 NextState( KWlanBgScanIntervalAutomatic ); |
|
788 |
|
789 } |
|
790 |
|
791 // --------------------------------------------------------------------------- |
|
792 // CWlanBgScan::DoSetInterval |
|
793 // --------------------------------------------------------------------------- |
|
794 // |
|
795 void CWlanBgScan::DoSetInterval( TUint32 aNewInterval ) |
|
796 { |
|
797 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 |
|
807 if ( ( currentInterval == 0 ) && ( aNewInterval != 0 ) ) |
|
808 { |
|
809 DEBUG( "CWlanBgScan::DoSetInterval() - current interval is zero and new interval is non-zero" ); |
|
810 DEBUG( "CWlanBgScan::DoSetInterval() - cancel scan and issue new with immediate expiry" ); |
|
811 iProvider.CancelScan(); |
|
812 SetInterval( aNewInterval ); |
|
813 NotConnected(); |
|
814 } |
|
815 else if ( currentInterval == aNewInterval ) |
|
816 { |
|
817 DEBUG( "CWlanBgScan::DoSetInterval() - no change in the interval" ); |
|
818 } |
|
819 else if ( currentInterval > aNewInterval ) |
|
820 { |
|
821 // if current interval greater than new interval -> cancel scan and |
|
822 // issue new with immediate expiry |
|
823 DEBUG( "CWlanBgScan::DoSetInterval() - current interval greater than the new interval" ); |
|
824 DEBUG( "CWlanBgScan::DoSetInterval() - cancel scan and issue new with immediate expiry" ); |
|
825 iProvider.CancelScan(); |
|
826 SetInterval( aNewInterval ); |
|
827 NotConnected(); |
|
828 } |
|
829 else |
|
830 { |
|
831 DEBUG( "CWlanBgScan::DoSetInterval() - current interval smaller than the new interval" ); |
|
832 DEBUG( "CWlanBgScan::DoSetInterval() - take new interval into use after currently pending scan is completed" ); |
|
833 SetInterval( aNewInterval ); |
|
834 } |
|
835 |
|
836 } |
|
837 |
|
838 // --------------------------------------------------------------------------- |
|
839 // CWlanBgScan::IsAwsPresent |
|
840 // -------------------------------------------------------------------------- |
|
841 // |
|
842 TBool CWlanBgScan::IsAwsPresent() |
|
843 { |
|
844 TBool ret( ETrue ); |
|
845 |
|
846 if( iAwsComms == NULL || !iAwsComms->IsAwsPresent() ) |
|
847 { |
|
848 ret = EFalse; |
|
849 } |
|
850 |
|
851 DEBUG1( "CWlanBgScan::IsAwsPresent() - returning %i", ret ); |
|
852 |
|
853 return ret; |
|
854 } |