--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/locationtriggering/ltserver/ltserverlogic/src/lbtcleanuphandler.cpp Tue Feb 02 01:06:48 2010 +0200
@@ -0,0 +1,538 @@
+/*
+* Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description: This file defines the clean up handler
+*
+*/
+
+
+// INCLUDE FILES
+#include <e32std.h>
+#include <lbtcommon.h>
+#include <f32file.h>
+#include <s32file.h>
+#include <centralrepository.h>
+#include "lbtcleanuphandler.h"
+#include "lbtcontainer.h"
+#include "lbtcontainerupdatefilter.h"
+#include "lbttriggerfilterbyattribute.h"
+#include "lbttriggeringsettingskeys.h"
+#include "lbtlogger.h"
+
+// LOCAL ENUMERATIONS
+
+enum
+ {
+ TLbtNone,
+ TLbtContainerCleaningUp,
+ TLbtWaitingForTimer
+ };
+
+// CONSTANTS
+_LIT(KLbtAppCleanupFileName, "lbtappcleanup.dat");
+
+// ======== LOCAL FUNCTIONS ========
+TInt CleanupItemOrder( const CLbtCleanupItem& aFirst, const CLbtCleanupItem& aSecond )
+ {
+ FUNC_ENTER("CleanupItemOrder");
+ const TTime& aFirstTime = aFirst.GetTime();
+ const TTime& aSecondTime = aSecond.GetTime();
+
+ if( aFirstTime == aSecondTime )
+ {
+ return 0;
+ }
+ else if( aFirstTime < aSecondTime )
+ {
+ return -1;
+ }
+ else
+ {
+ return 1;
+ }
+ }
+
+// ============ CLASS METHODS ==========
+
+// ---------------------------------------------------------------------------
+// CLbtCleanupHandler::NewL
+// ---------------------------------------------------------------------------
+//
+CLbtCleanupHandler* CLbtCleanupHandler::NewL( CLbtContainer& aContainer )
+ {
+ FUNC_ENTER("CLbtCleanupHandler::NewL");
+ CLbtCleanupHandler* self = new (ELeave) CLbtCleanupHandler( aContainer );
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+// ---------------------------------------------------------------------------
+// CLbtCleanupHandler::ConstructL
+// ---------------------------------------------------------------------------
+//
+void CLbtCleanupHandler::ConstructL()
+ {
+ FUNC_ENTER("CLbtCleanupHandler::ConstructL");
+ CTimer::ConstructL();
+ iOperation = TLbtNone;
+
+ CRepository* repository = CRepository::NewL(TUid::Uid(KCRUidLocationTriggeringSettings));
+ repository->Get(ELbtDaysForCleanup, iDaysForCleanup);
+ delete repository;
+
+ ReadCleanupDataFromFileL();
+ CleanupNextItemL();
+ }
+
+// ---------------------------------------------------------------------------
+// CLbtCleanupHandler::AddTriggersForCleanupL
+// ---------------------------------------------------------------------------
+//
+void CLbtCleanupHandler::AddTriggersForCleanupL( const RArray<TLbtTriggerId>& aTriggers )
+ {
+ FUNC_ENTER("CLbtCleanupHandler::AddTriggersForCleanupL");
+ CLbtCleanupItem* item = new(ELeave) CLbtCleanupItem;
+
+ TTime utcTime;
+ utcTime.UniversalTime();
+
+ TTimeIntervalDays cleanupDays(iDaysForCleanup);
+ utcTime += cleanupDays;
+
+ item->AddCleanupItem( aTriggers, utcTime );
+
+ TLinearOrder<CLbtCleanupItem> order(CleanupItemOrder);
+ iCleanupItems.InsertInOrder( item, order );
+
+ WriteCleanupDataToFileL();
+ CleanupNextItemL();
+ }
+
+// ---------------------------------------------------------------------------
+// CLbtCleanupHandler::RemoveTriggersFromCleanupL
+// ---------------------------------------------------------------------------
+//
+void CLbtCleanupHandler::RemoveTriggersFromCleanupL( const RArray<TLbtTriggerId>& aTriggers )
+ {
+ FUNC_ENTER("CLbtCleanupHandler::RemoveTriggersFromCleanupL");
+ // Bool to check if at the end of removal, current cleanup have to be aborted
+ TBool cancelCleanup = EFalse;
+
+ // Parse through cleanup items
+ for( TInt j=0;j<iCleanupItems.Count();++j )
+ {
+ RArray<TLbtTriggerId>& array = iCleanupItems[j]->GetTriggers();
+ for( TInt i=0;i<aTriggers.Count();++i )
+ {
+ TInt index = array.Find( aTriggers[i] );
+ if( index != KErrNotFound )
+ {
+ array.Remove(index);
+ }
+ }
+
+ if( array.Count() == 0 )
+ {
+ CLbtCleanupItem* item = iCleanupItems[j];
+ iCleanupItems.Remove(j);
+ delete item;
+ if( j==0 )
+ {
+ cancelCleanup = ETrue;
+ }
+ }
+ }
+
+ if( cancelCleanup )
+ {
+ Cancel();
+ }
+ WriteCleanupDataToFileL();
+ CleanupNextItemL();
+ }
+
+// ---------------------------------------------------------------------------
+// CLbtCleanupHandler::CleanupNextItemL
+// ---------------------------------------------------------------------------
+//
+void CLbtCleanupHandler::CleanupNextItemL()
+ {
+ FUNC_ENTER("CLbtCleanupHandler::CleanupNextItemL");
+ if( iCleanupItems.Count() > 0 &&
+ !IsActive() )
+ {
+ const TTime& utcTime = iCleanupItems[0]->GetTime();
+
+ // First get the universal time
+ TTime time;
+ time.UniversalTime();
+
+ if( time > utcTime )
+ {
+ // The UT has already elapsed
+ LOG("Provided UTC has already elapsed. Cleaning up Immediately");
+ iOperation = TLbtContainerCleaningUp;
+
+ // Get the trigger ids
+ RArray<TLbtTriggerId>& triggers = iCleanupItems[0]->GetTriggers();
+
+ CLbtTriggerFilterByAttribute* filterByAttribute = CLbtTriggerFilterByAttribute::NewL();
+ CleanupStack::PushL(filterByAttribute);
+
+ // Cleanup startup triggers
+ filterByAttribute->AddTriggerTypeL(CLbtTriggerEntry::ETypeStartup);
+
+ // Add the trigger ids trhat need to be cleanedup
+ for( TInt i=0;i<triggers.Count();++i )
+ {
+ filterByAttribute->AddTriggerIdL( triggers[i] );
+ }
+
+ CLbtContainerUpdateFilter* updateFilter = CLbtContainerUpdateFilter::NewL( filterByAttribute ,NULL );
+ iContainer.DeleteTriggers( updateFilter, iContainerOp, iStatus );
+ SetActive();
+
+ CleanupStack::Pop(filterByAttribute);
+ }
+ else
+ {
+ if( !IsActive() )
+ {
+ LOG("Waiting for Provided UTC")
+ // Wait for timer expiry
+ iOperation = TLbtWaitingForTimer;
+ AtUTC(utcTime);
+ }
+ }
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CLbtCleanupHandler::Cancel
+// ---------------------------------------------------------------------------
+//
+void CLbtCleanupHandler::Cancel()
+ {
+ FUNC_ENTER("CLbtCleanupHandler::Cancel");
+
+ if( IsActive() )
+ {
+ if( iOperation == TLbtContainerCleaningUp )
+ {
+ iContainer.CancelAsyncOperation( iContainerOp );
+ }
+ else if( iOperation == TLbtWaitingForTimer )
+ {
+ CTimer::Cancel();
+ }
+ }
+ iOperation = TLbtNone;
+ }
+
+
+// ---------------------------------------------------------------------------
+// CLbtCleanupHandler::RunL
+// ---------------------------------------------------------------------------
+//
+void CLbtCleanupHandler::RunL()
+ {
+ FUNC_ENTER("CLbtCleanupHandler::RunL");
+ LOG1("iOperation %d",iOperation);
+
+ if( iStatus.Int() != KErrNone )
+ {
+ LOG1("CLbtCleanupHandler, iStatus = %d", iStatus.Int());
+ return;
+ }
+
+ switch(iOperation)
+ {
+ case TLbtContainerCleaningUp:
+ {
+ CLbtCleanupItem* item = iCleanupItems[0];
+ iCleanupItems.Remove(0);
+ delete item;
+ iOperation = TLbtNone;
+ WriteCleanupDataToFileL();
+ CleanupNextItemL();
+ break;
+ }
+ case TLbtWaitingForTimer:
+ {
+ LOG("Timer has expired. Cleaning triggers");
+ iOperation = TLbtContainerCleaningUp;
+
+ // Get the trigger ids
+ RArray<TLbtTriggerId>& triggers = iCleanupItems[0]->GetTriggers();
+
+ CLbtTriggerFilterByAttribute* filterByAttribute = CLbtTriggerFilterByAttribute::NewL();
+ CleanupStack::PushL(filterByAttribute);
+
+ // Cleanup startup triggers
+ filterByAttribute->AddTriggerTypeL(CLbtTriggerEntry::ETypeStartup);
+
+ // Add the trigger ids trhat need to be cleaned up
+ for( TInt i=0;i<triggers.Count();++i )
+ {
+ filterByAttribute->AddTriggerIdL( triggers[i] );
+ }
+
+ CLbtContainerUpdateFilter* updateFilter = CLbtContainerUpdateFilter::NewL( filterByAttribute ,NULL );
+ iContainer.DeleteTriggers( updateFilter, iContainerOp, iStatus );
+ SetActive();
+
+ CleanupStack::Pop(filterByAttribute);
+ break;
+ }
+ default:
+ {
+ iOperation = TLbtNone;
+ break;
+ }
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CLbtCleanupHandler::RunError
+// ---------------------------------------------------------------------------
+//
+TInt CLbtCleanupHandler::RunError( TInt aError )
+ {
+ FUNC_ENTER("CLbtCleanupHandler::RunError");
+ ERROR("CLbtCleanupHandler::RunL left with error code", aError);
+ return KErrNone;
+ }
+
+// ---------------------------------------------------------------------------
+// CLbtCleanupHandler::WriteCleanupDataToFileL
+// ---------------------------------------------------------------------------
+//
+void CLbtCleanupHandler::WriteCleanupDataToFileL()
+ {
+ FUNC_ENTER("CLbtCleanupHandler::WriteCleanupDataToFileL");
+
+ RFs fs;
+ User::LeaveIfError( fs.Connect() );
+
+ CleanupClosePushL( fs );
+
+ // Obtain the file path
+ TFileName file;
+
+ // Gets the path in which the file can be created
+ fs.SessionPath(file);
+
+ // Create the file Directory ie the private directory of the process
+ fs.MkDirAll(file);
+
+ // Append the name of the file
+ file.Append(KLbtAppCleanupFileName);
+
+ // Open write stream to write to the file
+ RFileWriteStream writeStream;
+
+ // Open the file to replace the contents. If the file is not preset
+ // this method will create the file
+ TInt error = writeStream.Replace( fs, file, EFileWrite );
+ if( error != KErrNone )
+ {
+ ERROR("Opening of cleanup file failed with : %d", error);
+ writeStream.Close();
+ CleanupStack::PopAndDestroy(); //fs
+ User::Leave(error);
+ }
+ CleanupClosePushL( writeStream );
+
+ // First write the number of cleanup items
+ writeStream.WriteInt16L( iCleanupItems.Count() );
+
+ for(TInt i=0;i<iCleanupItems.Count();++i)
+ {
+ RArray<TLbtTriggerId>& triggers = iCleanupItems[i]->GetTriggers();
+
+ // Write the trigger ids into the file
+ writeStream.WriteInt16L( triggers.Count() );
+ for(TInt j=0;j<triggers.Count();++j)
+ {
+ writeStream.WriteUint32L( triggers[j] );
+ }
+
+ // Write the time into the file
+ const TDateTime dateTime = iCleanupItems[i]->GetTime().DateTime();
+
+ // Write the year
+ writeStream.WriteInt32L( dateTime.Year() );
+
+ // Write the month
+ writeStream.WriteInt32L( dateTime.Month() );
+
+ // Write the day
+ writeStream.WriteInt32L( dateTime.Day() );
+ }
+
+ CleanupStack::PopAndDestroy(2); //fs and writeSteam
+ }
+
+// ---------------------------------------------------------------------------
+// CLbtCleanupHandler::ReadCleanupDataFromFileL
+// ---------------------------------------------------------------------------
+//
+void CLbtCleanupHandler::ReadCleanupDataFromFileL()
+ {
+ FUNC_ENTER("CLbtCleanupHandler::ReadCleanupDataFromFileL");
+
+ // First reset the cleanup data
+ iCleanupItems.ResetAndDestroy();
+
+ // Open handle to file system
+ RFs fs;
+ User::LeaveIfError(fs.Connect());
+
+ CleanupClosePushL(fs);
+
+ // Obtain the file path
+ TFileName file;
+
+ // Gets the path in which the file can be created
+ fs.SessionPath(file);
+
+ // Create the file Directory ie the private directory of the process
+ fs.MkDirAll(file);
+
+ // Append the name of the file
+ file.Append(KLbtAppCleanupFileName);
+
+ // Open read stream
+ RFileReadStream readStream;
+
+ TInt error = readStream.Open( fs, file, EFileRead );
+ if( error != KErrNone )
+ {
+ // File may not exists
+ ERROR("Opening of cleanup file failed with : %d", error);
+ readStream.Close();
+ CleanupStack::PopAndDestroy(); //fs
+ return;
+ }
+ CleanupClosePushL( readStream );
+
+ // Get the count in the cleanup array
+ TInt count = readStream.ReadInt16L();
+ for(TInt i=0; i<count; ++i)
+ {
+ RArray<TLbtTriggerId> triggers;
+ CleanupClosePushL(triggers);
+
+ // Read the trigger ids
+ TInt triggerCount = readStream.ReadInt16L();
+ for(TInt j=0;j<triggerCount;++j)
+ {
+ triggers.Append( readStream.ReadUint32L() );
+ }
+
+ // Read the universal time
+ TInt year = readStream.ReadInt32L();
+ TMonth month = static_cast<TMonth>( readStream.ReadInt32L() );
+ TInt day = readStream.ReadInt32L();
+
+ TDateTime dateTime( year,
+ month,
+ day,
+ 0,
+ 0,
+ 0,
+ 0 );
+ TTime time( dateTime );
+
+ CLbtCleanupItem* cleanupItem = new (ELeave) CLbtCleanupItem();
+ cleanupItem->AddCleanupItem( triggers, time );
+
+ CleanupStack::Pop(); // triggers
+ triggers.Close();
+
+ // Append cleanup item to the cleaup items array
+ iCleanupItems.Append( cleanupItem );
+ }
+
+ CleanupStack::PopAndDestroy(2); // fs and readStream
+ }
+
+// ---------------------------------------------------------------------------
+// CLbtCleanupHandler::~CLbtCleanupHandler
+// ---------------------------------------------------------------------------
+//
+CLbtCleanupHandler::~CLbtCleanupHandler()
+ {
+ FUNC_ENTER("CLbtCleanupHandler::~CLbtCleanupHandler");
+ Cancel();
+ iCleanupItems.ResetAndDestroy();
+ }
+
+// ---------------------------------------------------------------------------
+// CLbtCleanupHandler::CLbtCleanupHandler
+// ---------------------------------------------------------------------------
+//
+CLbtCleanupHandler::CLbtCleanupHandler( CLbtContainer& aContainer ):
+ CTimer(CActive::EPriorityLow),
+ iContainer( aContainer )
+ {
+ CActiveScheduler::Add(this);
+ }
+
+// ---------------------------------------------------------------------------
+// CLbtCleanupItem::AddCleanupItem
+// ---------------------------------------------------------------------------
+//
+void CLbtCleanupItem::AddCleanupItem( const RArray<TLbtTriggerId>& aTriggers, TTime& aUTCTime )
+ {
+ FUNC_ENTER("CLbtCleanupItem::AddCleanupItem");
+ iTriggers.Reset();
+ for(TInt i=0;i<aTriggers.Count();++i)
+ {
+ iTriggers.Append( aTriggers[i] );
+ }
+ iUTCTime = aUTCTime;
+ }
+
+// ---------------------------------------------------------------------------
+// CLbtCleanupItem::GetTime
+// ---------------------------------------------------------------------------
+//
+const TTime& CLbtCleanupItem::GetTime() const
+ {
+ return iUTCTime;
+ }
+
+// ---------------------------------------------------------------------------
+// CLbtCleanupItem::GetTriggers
+// ---------------------------------------------------------------------------
+//
+RArray<TLbtTriggerId>& CLbtCleanupItem::GetTriggers()
+ {
+ return iTriggers;
+ }
+
+// ---------------------------------------------------------------------------
+// CLbtCleanupItem::~CLbtCleanupItem
+// ---------------------------------------------------------------------------
+//
+CLbtCleanupItem::~CLbtCleanupItem()
+ {
+ FUNC_ENTER("CLbtCleanupItem::~CLbtCleanupItem");
+ iTriggers.Close();
+ }
+
+// end of file
+