|
1 /* |
|
2 * Copyright (c) 2006 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 "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 file defines the clean up handler |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 // INCLUDE FILES |
|
20 #include <e32std.h> |
|
21 #include <lbtcommon.h> |
|
22 #include <f32file.h> |
|
23 #include <s32file.h> |
|
24 #include <centralrepository.h> |
|
25 #include "lbtcleanuphandler.h" |
|
26 #include "lbtcontainer.h" |
|
27 #include "lbtcontainerupdatefilter.h" |
|
28 #include "lbttriggerfilterbyattribute.h" |
|
29 #include "lbttriggeringsettingskeys.h" |
|
30 #include "lbtlogger.h" |
|
31 |
|
32 // LOCAL ENUMERATIONS |
|
33 |
|
34 enum |
|
35 { |
|
36 TLbtNone, |
|
37 TLbtContainerCleaningUp, |
|
38 TLbtWaitingForTimer |
|
39 }; |
|
40 |
|
41 // CONSTANTS |
|
42 _LIT(KLbtAppCleanupFileName, "lbtappcleanup.dat"); |
|
43 |
|
44 // ======== LOCAL FUNCTIONS ======== |
|
45 TInt CleanupItemOrder( const CLbtCleanupItem& aFirst, const CLbtCleanupItem& aSecond ) |
|
46 { |
|
47 FUNC_ENTER("CleanupItemOrder"); |
|
48 const TTime& aFirstTime = aFirst.GetTime(); |
|
49 const TTime& aSecondTime = aSecond.GetTime(); |
|
50 |
|
51 if( aFirstTime == aSecondTime ) |
|
52 { |
|
53 return 0; |
|
54 } |
|
55 else if( aFirstTime < aSecondTime ) |
|
56 { |
|
57 return -1; |
|
58 } |
|
59 else |
|
60 { |
|
61 return 1; |
|
62 } |
|
63 } |
|
64 |
|
65 // ============ CLASS METHODS ========== |
|
66 |
|
67 // --------------------------------------------------------------------------- |
|
68 // CLbtCleanupHandler::NewL |
|
69 // --------------------------------------------------------------------------- |
|
70 // |
|
71 CLbtCleanupHandler* CLbtCleanupHandler::NewL( CLbtContainer& aContainer ) |
|
72 { |
|
73 FUNC_ENTER("CLbtCleanupHandler::NewL"); |
|
74 CLbtCleanupHandler* self = new (ELeave) CLbtCleanupHandler( aContainer ); |
|
75 CleanupStack::PushL(self); |
|
76 self->ConstructL(); |
|
77 CleanupStack::Pop(self); |
|
78 return self; |
|
79 } |
|
80 |
|
81 // --------------------------------------------------------------------------- |
|
82 // CLbtCleanupHandler::ConstructL |
|
83 // --------------------------------------------------------------------------- |
|
84 // |
|
85 void CLbtCleanupHandler::ConstructL() |
|
86 { |
|
87 FUNC_ENTER("CLbtCleanupHandler::ConstructL"); |
|
88 CTimer::ConstructL(); |
|
89 iOperation = TLbtNone; |
|
90 |
|
91 CRepository* repository = CRepository::NewL(TUid::Uid(KCRUidLocationTriggeringSettings)); |
|
92 repository->Get(ELbtDaysForCleanup, iDaysForCleanup); |
|
93 delete repository; |
|
94 |
|
95 ReadCleanupDataFromFileL(); |
|
96 CleanupNextItemL(); |
|
97 } |
|
98 |
|
99 // --------------------------------------------------------------------------- |
|
100 // CLbtCleanupHandler::AddTriggersForCleanupL |
|
101 // --------------------------------------------------------------------------- |
|
102 // |
|
103 void CLbtCleanupHandler::AddTriggersForCleanupL( const RArray<TLbtTriggerId>& aTriggers ) |
|
104 { |
|
105 FUNC_ENTER("CLbtCleanupHandler::AddTriggersForCleanupL"); |
|
106 CLbtCleanupItem* item = new(ELeave) CLbtCleanupItem; |
|
107 |
|
108 TTime utcTime; |
|
109 utcTime.UniversalTime(); |
|
110 |
|
111 TTimeIntervalDays cleanupDays(iDaysForCleanup); |
|
112 utcTime += cleanupDays; |
|
113 |
|
114 item->AddCleanupItem( aTriggers, utcTime ); |
|
115 |
|
116 TLinearOrder<CLbtCleanupItem> order(CleanupItemOrder); |
|
117 iCleanupItems.InsertInOrder( item, order ); |
|
118 |
|
119 WriteCleanupDataToFileL(); |
|
120 CleanupNextItemL(); |
|
121 } |
|
122 |
|
123 // --------------------------------------------------------------------------- |
|
124 // CLbtCleanupHandler::RemoveTriggersFromCleanupL |
|
125 // --------------------------------------------------------------------------- |
|
126 // |
|
127 void CLbtCleanupHandler::RemoveTriggersFromCleanupL( const RArray<TLbtTriggerId>& aTriggers ) |
|
128 { |
|
129 FUNC_ENTER("CLbtCleanupHandler::RemoveTriggersFromCleanupL"); |
|
130 // Bool to check if at the end of removal, current cleanup have to be aborted |
|
131 TBool cancelCleanup = EFalse; |
|
132 |
|
133 // Parse through cleanup items |
|
134 for( TInt j=0;j<iCleanupItems.Count();++j ) |
|
135 { |
|
136 RArray<TLbtTriggerId>& array = iCleanupItems[j]->GetTriggers(); |
|
137 for( TInt i=0;i<aTriggers.Count();++i ) |
|
138 { |
|
139 TInt index = array.Find( aTriggers[i] ); |
|
140 if( index != KErrNotFound ) |
|
141 { |
|
142 array.Remove(index); |
|
143 } |
|
144 } |
|
145 |
|
146 if( array.Count() == 0 ) |
|
147 { |
|
148 CLbtCleanupItem* item = iCleanupItems[j]; |
|
149 iCleanupItems.Remove(j); |
|
150 delete item; |
|
151 if( j==0 ) |
|
152 { |
|
153 cancelCleanup = ETrue; |
|
154 } |
|
155 } |
|
156 } |
|
157 |
|
158 if( cancelCleanup ) |
|
159 { |
|
160 Cancel(); |
|
161 } |
|
162 WriteCleanupDataToFileL(); |
|
163 CleanupNextItemL(); |
|
164 } |
|
165 |
|
166 // --------------------------------------------------------------------------- |
|
167 // CLbtCleanupHandler::CleanupNextItemL |
|
168 // --------------------------------------------------------------------------- |
|
169 // |
|
170 void CLbtCleanupHandler::CleanupNextItemL() |
|
171 { |
|
172 FUNC_ENTER("CLbtCleanupHandler::CleanupNextItemL"); |
|
173 if( iCleanupItems.Count() > 0 && |
|
174 !IsActive() ) |
|
175 { |
|
176 const TTime& utcTime = iCleanupItems[0]->GetTime(); |
|
177 |
|
178 // First get the universal time |
|
179 TTime time; |
|
180 time.UniversalTime(); |
|
181 |
|
182 if( time > utcTime ) |
|
183 { |
|
184 // The UT has already elapsed |
|
185 LOG("Provided UTC has already elapsed. Cleaning up Immediately"); |
|
186 iOperation = TLbtContainerCleaningUp; |
|
187 |
|
188 // Get the trigger ids |
|
189 RArray<TLbtTriggerId>& triggers = iCleanupItems[0]->GetTriggers(); |
|
190 |
|
191 CLbtTriggerFilterByAttribute* filterByAttribute = CLbtTriggerFilterByAttribute::NewL(); |
|
192 CleanupStack::PushL(filterByAttribute); |
|
193 |
|
194 // Cleanup startup triggers |
|
195 filterByAttribute->AddTriggerTypeL(CLbtTriggerEntry::ETypeStartup); |
|
196 |
|
197 // Add the trigger ids trhat need to be cleanedup |
|
198 for( TInt i=0;i<triggers.Count();++i ) |
|
199 { |
|
200 filterByAttribute->AddTriggerIdL( triggers[i] ); |
|
201 } |
|
202 |
|
203 CLbtContainerUpdateFilter* updateFilter = CLbtContainerUpdateFilter::NewL( filterByAttribute ,NULL ); |
|
204 iContainer.DeleteTriggers( updateFilter, iContainerOp, iStatus ); |
|
205 SetActive(); |
|
206 |
|
207 CleanupStack::Pop(filterByAttribute); |
|
208 } |
|
209 else |
|
210 { |
|
211 if( !IsActive() ) |
|
212 { |
|
213 LOG("Waiting for Provided UTC") |
|
214 // Wait for timer expiry |
|
215 iOperation = TLbtWaitingForTimer; |
|
216 AtUTC(utcTime); |
|
217 } |
|
218 } |
|
219 } |
|
220 } |
|
221 |
|
222 // --------------------------------------------------------------------------- |
|
223 // CLbtCleanupHandler::Cancel |
|
224 // --------------------------------------------------------------------------- |
|
225 // |
|
226 void CLbtCleanupHandler::Cancel() |
|
227 { |
|
228 FUNC_ENTER("CLbtCleanupHandler::Cancel"); |
|
229 |
|
230 if( IsActive() ) |
|
231 { |
|
232 if( iOperation == TLbtContainerCleaningUp ) |
|
233 { |
|
234 iContainer.CancelAsyncOperation( iContainerOp ); |
|
235 } |
|
236 else if( iOperation == TLbtWaitingForTimer ) |
|
237 { |
|
238 CTimer::Cancel(); |
|
239 } |
|
240 } |
|
241 iOperation = TLbtNone; |
|
242 } |
|
243 |
|
244 |
|
245 // --------------------------------------------------------------------------- |
|
246 // CLbtCleanupHandler::RunL |
|
247 // --------------------------------------------------------------------------- |
|
248 // |
|
249 void CLbtCleanupHandler::RunL() |
|
250 { |
|
251 FUNC_ENTER("CLbtCleanupHandler::RunL"); |
|
252 LOG1("iOperation %d",iOperation); |
|
253 |
|
254 if( iStatus.Int() != KErrNone ) |
|
255 { |
|
256 LOG1("CLbtCleanupHandler, iStatus = %d", iStatus.Int()); |
|
257 return; |
|
258 } |
|
259 |
|
260 switch(iOperation) |
|
261 { |
|
262 case TLbtContainerCleaningUp: |
|
263 { |
|
264 CLbtCleanupItem* item = iCleanupItems[0]; |
|
265 iCleanupItems.Remove(0); |
|
266 delete item; |
|
267 iOperation = TLbtNone; |
|
268 WriteCleanupDataToFileL(); |
|
269 CleanupNextItemL(); |
|
270 break; |
|
271 } |
|
272 case TLbtWaitingForTimer: |
|
273 { |
|
274 LOG("Timer has expired. Cleaning triggers"); |
|
275 iOperation = TLbtContainerCleaningUp; |
|
276 |
|
277 // Get the trigger ids |
|
278 RArray<TLbtTriggerId>& triggers = iCleanupItems[0]->GetTriggers(); |
|
279 |
|
280 CLbtTriggerFilterByAttribute* filterByAttribute = CLbtTriggerFilterByAttribute::NewL(); |
|
281 CleanupStack::PushL(filterByAttribute); |
|
282 |
|
283 // Cleanup startup triggers |
|
284 filterByAttribute->AddTriggerTypeL(CLbtTriggerEntry::ETypeStartup); |
|
285 |
|
286 // Add the trigger ids trhat need to be cleaned up |
|
287 for( TInt i=0;i<triggers.Count();++i ) |
|
288 { |
|
289 filterByAttribute->AddTriggerIdL( triggers[i] ); |
|
290 } |
|
291 |
|
292 CLbtContainerUpdateFilter* updateFilter = CLbtContainerUpdateFilter::NewL( filterByAttribute ,NULL ); |
|
293 iContainer.DeleteTriggers( updateFilter, iContainerOp, iStatus ); |
|
294 SetActive(); |
|
295 |
|
296 CleanupStack::Pop(filterByAttribute); |
|
297 break; |
|
298 } |
|
299 default: |
|
300 { |
|
301 iOperation = TLbtNone; |
|
302 break; |
|
303 } |
|
304 } |
|
305 } |
|
306 |
|
307 // --------------------------------------------------------------------------- |
|
308 // CLbtCleanupHandler::RunError |
|
309 // --------------------------------------------------------------------------- |
|
310 // |
|
311 TInt CLbtCleanupHandler::RunError( TInt aError ) |
|
312 { |
|
313 FUNC_ENTER("CLbtCleanupHandler::RunError"); |
|
314 ERROR("CLbtCleanupHandler::RunL left with error code", aError); |
|
315 return KErrNone; |
|
316 } |
|
317 |
|
318 // --------------------------------------------------------------------------- |
|
319 // CLbtCleanupHandler::WriteCleanupDataToFileL |
|
320 // --------------------------------------------------------------------------- |
|
321 // |
|
322 void CLbtCleanupHandler::WriteCleanupDataToFileL() |
|
323 { |
|
324 FUNC_ENTER("CLbtCleanupHandler::WriteCleanupDataToFileL"); |
|
325 |
|
326 RFs fs; |
|
327 User::LeaveIfError( fs.Connect() ); |
|
328 |
|
329 CleanupClosePushL( fs ); |
|
330 |
|
331 // Obtain the file path |
|
332 TFileName file; |
|
333 |
|
334 // Gets the path in which the file can be created |
|
335 fs.SessionPath(file); |
|
336 |
|
337 // Create the file Directory ie the private directory of the process |
|
338 fs.MkDirAll(file); |
|
339 |
|
340 // Append the name of the file |
|
341 file.Append(KLbtAppCleanupFileName); |
|
342 |
|
343 // Open write stream to write to the file |
|
344 RFileWriteStream writeStream; |
|
345 |
|
346 // Open the file to replace the contents. If the file is not preset |
|
347 // this method will create the file |
|
348 TInt error = writeStream.Replace( fs, file, EFileWrite ); |
|
349 if( error != KErrNone ) |
|
350 { |
|
351 ERROR("Opening of cleanup file failed with : %d", error); |
|
352 writeStream.Close(); |
|
353 CleanupStack::PopAndDestroy(); //fs |
|
354 User::Leave(error); |
|
355 } |
|
356 CleanupClosePushL( writeStream ); |
|
357 |
|
358 // First write the number of cleanup items |
|
359 writeStream.WriteInt16L( iCleanupItems.Count() ); |
|
360 |
|
361 for(TInt i=0;i<iCleanupItems.Count();++i) |
|
362 { |
|
363 RArray<TLbtTriggerId>& triggers = iCleanupItems[i]->GetTriggers(); |
|
364 |
|
365 // Write the trigger ids into the file |
|
366 writeStream.WriteInt16L( triggers.Count() ); |
|
367 for(TInt j=0;j<triggers.Count();++j) |
|
368 { |
|
369 writeStream.WriteUint32L( triggers[j] ); |
|
370 } |
|
371 |
|
372 // Write the time into the file |
|
373 const TDateTime dateTime = iCleanupItems[i]->GetTime().DateTime(); |
|
374 |
|
375 // Write the year |
|
376 writeStream.WriteInt32L( dateTime.Year() ); |
|
377 |
|
378 // Write the month |
|
379 writeStream.WriteInt32L( dateTime.Month() ); |
|
380 |
|
381 // Write the day |
|
382 writeStream.WriteInt32L( dateTime.Day() ); |
|
383 } |
|
384 |
|
385 CleanupStack::PopAndDestroy(2); //fs and writeSteam |
|
386 } |
|
387 |
|
388 // --------------------------------------------------------------------------- |
|
389 // CLbtCleanupHandler::ReadCleanupDataFromFileL |
|
390 // --------------------------------------------------------------------------- |
|
391 // |
|
392 void CLbtCleanupHandler::ReadCleanupDataFromFileL() |
|
393 { |
|
394 FUNC_ENTER("CLbtCleanupHandler::ReadCleanupDataFromFileL"); |
|
395 |
|
396 // First reset the cleanup data |
|
397 iCleanupItems.ResetAndDestroy(); |
|
398 |
|
399 // Open handle to file system |
|
400 RFs fs; |
|
401 User::LeaveIfError(fs.Connect()); |
|
402 |
|
403 CleanupClosePushL(fs); |
|
404 |
|
405 // Obtain the file path |
|
406 TFileName file; |
|
407 |
|
408 // Gets the path in which the file can be created |
|
409 fs.SessionPath(file); |
|
410 |
|
411 // Create the file Directory ie the private directory of the process |
|
412 fs.MkDirAll(file); |
|
413 |
|
414 // Append the name of the file |
|
415 file.Append(KLbtAppCleanupFileName); |
|
416 |
|
417 // Open read stream |
|
418 RFileReadStream readStream; |
|
419 |
|
420 TInt error = readStream.Open( fs, file, EFileRead ); |
|
421 if( error != KErrNone ) |
|
422 { |
|
423 // File may not exists |
|
424 ERROR("Opening of cleanup file failed with : %d", error); |
|
425 readStream.Close(); |
|
426 CleanupStack::PopAndDestroy(); //fs |
|
427 return; |
|
428 } |
|
429 CleanupClosePushL( readStream ); |
|
430 |
|
431 // Get the count in the cleanup array |
|
432 TInt count = readStream.ReadInt16L(); |
|
433 for(TInt i=0; i<count; ++i) |
|
434 { |
|
435 RArray<TLbtTriggerId> triggers; |
|
436 CleanupClosePushL(triggers); |
|
437 |
|
438 // Read the trigger ids |
|
439 TInt triggerCount = readStream.ReadInt16L(); |
|
440 for(TInt j=0;j<triggerCount;++j) |
|
441 { |
|
442 triggers.Append( readStream.ReadUint32L() ); |
|
443 } |
|
444 |
|
445 // Read the universal time |
|
446 TInt year = readStream.ReadInt32L(); |
|
447 TMonth month = static_cast<TMonth>( readStream.ReadInt32L() ); |
|
448 TInt day = readStream.ReadInt32L(); |
|
449 |
|
450 TDateTime dateTime( year, |
|
451 month, |
|
452 day, |
|
453 0, |
|
454 0, |
|
455 0, |
|
456 0 ); |
|
457 TTime time( dateTime ); |
|
458 |
|
459 CLbtCleanupItem* cleanupItem = new (ELeave) CLbtCleanupItem(); |
|
460 cleanupItem->AddCleanupItem( triggers, time ); |
|
461 |
|
462 CleanupStack::Pop(); // triggers |
|
463 triggers.Close(); |
|
464 |
|
465 // Append cleanup item to the cleaup items array |
|
466 iCleanupItems.Append( cleanupItem ); |
|
467 } |
|
468 |
|
469 CleanupStack::PopAndDestroy(2); // fs and readStream |
|
470 } |
|
471 |
|
472 // --------------------------------------------------------------------------- |
|
473 // CLbtCleanupHandler::~CLbtCleanupHandler |
|
474 // --------------------------------------------------------------------------- |
|
475 // |
|
476 CLbtCleanupHandler::~CLbtCleanupHandler() |
|
477 { |
|
478 FUNC_ENTER("CLbtCleanupHandler::~CLbtCleanupHandler"); |
|
479 Cancel(); |
|
480 iCleanupItems.ResetAndDestroy(); |
|
481 } |
|
482 |
|
483 // --------------------------------------------------------------------------- |
|
484 // CLbtCleanupHandler::CLbtCleanupHandler |
|
485 // --------------------------------------------------------------------------- |
|
486 // |
|
487 CLbtCleanupHandler::CLbtCleanupHandler( CLbtContainer& aContainer ): |
|
488 CTimer(CActive::EPriorityLow), |
|
489 iContainer( aContainer ) |
|
490 { |
|
491 CActiveScheduler::Add(this); |
|
492 } |
|
493 |
|
494 // --------------------------------------------------------------------------- |
|
495 // CLbtCleanupItem::AddCleanupItem |
|
496 // --------------------------------------------------------------------------- |
|
497 // |
|
498 void CLbtCleanupItem::AddCleanupItem( const RArray<TLbtTriggerId>& aTriggers, TTime& aUTCTime ) |
|
499 { |
|
500 FUNC_ENTER("CLbtCleanupItem::AddCleanupItem"); |
|
501 iTriggers.Reset(); |
|
502 for(TInt i=0;i<aTriggers.Count();++i) |
|
503 { |
|
504 iTriggers.Append( aTriggers[i] ); |
|
505 } |
|
506 iUTCTime = aUTCTime; |
|
507 } |
|
508 |
|
509 // --------------------------------------------------------------------------- |
|
510 // CLbtCleanupItem::GetTime |
|
511 // --------------------------------------------------------------------------- |
|
512 // |
|
513 const TTime& CLbtCleanupItem::GetTime() const |
|
514 { |
|
515 return iUTCTime; |
|
516 } |
|
517 |
|
518 // --------------------------------------------------------------------------- |
|
519 // CLbtCleanupItem::GetTriggers |
|
520 // --------------------------------------------------------------------------- |
|
521 // |
|
522 RArray<TLbtTriggerId>& CLbtCleanupItem::GetTriggers() |
|
523 { |
|
524 return iTriggers; |
|
525 } |
|
526 |
|
527 // --------------------------------------------------------------------------- |
|
528 // CLbtCleanupItem::~CLbtCleanupItem |
|
529 // --------------------------------------------------------------------------- |
|
530 // |
|
531 CLbtCleanupItem::~CLbtCleanupItem() |
|
532 { |
|
533 FUNC_ENTER("CLbtCleanupItem::~CLbtCleanupItem"); |
|
534 iTriggers.Close(); |
|
535 } |
|
536 |
|
537 // end of file |
|
538 |