diff -r 000000000000 -r ba25891c3a9e appinstaller/AppinstUi/Plugin/TaskManager/Src/TaskManagerImpl.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/appinstaller/AppinstUi/Plugin/TaskManager/Src/TaskManagerImpl.cpp Thu Dec 17 08:51:10 2009 +0200 @@ -0,0 +1,451 @@ +/* +* Copyright (c) 2002-2004 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 module contains the implementation of CTaskManagerImpl +* class member functions. +* +*/ + + +// INCLUDE FILES + +#include +#include + +#include "TaskManagerImpl.h" +#include "SWInstTask.h" + +using namespace SwiUI; + +_LIT( KTaskDir, "Tasks\\" ); +_LIT( KTaskListMatch, "*" ); + +const TUint KMaxNumLength = 20; + + +// ============================ MEMBER FUNCTIONS =============================== + +// ----------------------------------------------------------------------------- +// CTaskManagerImpl::CTaskManagerImpl +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +CTaskManagerImpl::CTaskManagerImpl() + { + } + +// ----------------------------------------------------------------------------- +// CTaskManagerImpl::ConstructL +// Symbian 2nd phase constructor can leave. +// ----------------------------------------------------------------------------- +// +void CTaskManagerImpl::ConstructL() + { + User::LeaveIfError( iRFs.Connect() ); + } + +// ----------------------------------------------------------------------------- +// CTaskManagerImpl::NewL +// Two-phased constructor. +// ----------------------------------------------------------------------------- +// +CTaskManagerImpl* CTaskManagerImpl::NewL() + { + CTaskManagerImpl* self = new( ELeave ) CTaskManagerImpl(); + CleanupStack::PushL( self ); + self->ConstructL(); + CleanupStack::Pop( self ); + return self; + } + +// Destructor +CTaskManagerImpl::~CTaskManagerImpl() + { + iTaskList.ResetAndDestroy(); + iRFs.Close(); + } + +// ----------------------------------------------------------------------------- +// TaskManagerImpl::AddTaskL +// Adds a task to the task list. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CTaskManagerImpl::AddTaskL( CTask* aTask ) + { + iTaskList.Append( aTask ); + } + +// ----------------------------------------------------------------------------- +// TaskManagerImpl::RemoveTaskL +// Removes a task from the task list. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CTaskManagerImpl::RemoveTaskL( CTask* aTask ) + { + TInt index = iTaskList.Find( aTask ); + + if ( aTask->IsPersistent() ) + { + RemovePersistentTask( *aTask ); + } + + iTaskList.Remove( index ); + delete aTask; + } + +// ----------------------------------------------------------------------------- +// TaskManagerImpl::FlushTasks +// Removes tasks from task list without executing them. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CTaskManagerImpl::FlushTasks() + { + while ( iTaskList.Count() ) + { + CTask* task = iTaskList[0]; + iTaskList.Remove( 0 ); + + if ( task->IsPersistent() ) + { + RemovePersistentTask( *task ); + } + + delete task; + } + + iTaskList.Reset(); + } + +// ----------------------------------------------------------------------------- +// TaskManagerImpl::ExecutePendingTasksL +// Executes all pending tasks that are added to the task list within the +// lifetime of this thread. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CTaskManagerImpl::ExecutePendingTasksL() + { + TInt error( KErrNone ); + + while ( iTaskList.Count() ) + { + CTask* task = iTaskList[0]; + TRAP( error, task->ExecuteL() ); + iTaskList.Remove( 0 ); + + if ( error == KErrNone && task->IsPersistent() ) + { + RemovePersistentTask( *task ); + } + + delete task; + } + + iTaskList.Reset(); + + if ( error != KErrNone ) + { + User::Leave( error ); + } + } + +// ----------------------------------------------------------------------------- +// TaskManagerImpl::ExecuteRecoveryTasksL +// Executes all tasks from non persistent and persistent memory. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CTaskManagerImpl::ExecuteRecoveryTasksL() + { + TInt error( KErrNone ); + + PopulatePersistentTasksL(); + + while ( iTaskList.Count() ) + { + CTask* task = iTaskList[0]; + TRAP( error, task->ExecuteL() ); + iTaskList.Remove( 0 ); + + if ( task->IsPersistent() ) + { + RemovePersistentTask( *task ); + } + + delete task; + } + + iTaskList.Reset(); + DeleteTaskFilesL(); + + if ( error != KErrNone ) + { + User::Leave( error ); + } + } + +// ----------------------------------------------------------------------------- +// TaskManagerImpl::CommitL +// Writes all persistent tasks from the task list to a persistent storage. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CTaskManagerImpl::CommitL() + { + CreateTaskDirL(); + + for ( TInt index = 0; index < iTaskList.Count(); index++ ) + { + CTask* task = iTaskList[index]; + + // Write to store only if this task is persistent and it has no id + // (already written) + if ( task->IsPersistent() && !task->Id() ) + { + // Get an id for the task + TInt id = GetFreeTaskIdL(); + task->SetId( id ); + + // Create stream + RFileWriteStream stream; + stream.PushL(); + TFileName filePath; + GetTaskFilePath( filePath, id ); + User::LeaveIfError( stream.Create( iRFs, filePath, EFileWrite ) ); + + // Externalize task + stream.WriteInt32L( task->ImplementationUid().iUid ); + stream << *task; + stream.CommitL(); + CleanupStack::PopAndDestroy(); // stream + } + } + } + +// ----------------------------------------------------------------------------- +// TaskManagerImpl::IncreaseClientCount +// Increase the count of clients. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CTaskManagerImpl::IncreaseClientCount() + { + ++iClientCount; + } + +// ----------------------------------------------------------------------------- +// TaskManagerImpl::DecreaseClientCount +// Decrease the count of clients. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CTaskManagerImpl::DecreaseClientCount() + { + --iClientCount; + } + +// ----------------------------------------------------------------------------- +// TaskManagerImpl::CanBeFreed +// Indicates if no more clients have open instances and memory can be freed. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +TBool CTaskManagerImpl::CanBeFreed() + { + if ( iClientCount > 0 ) + { + return EFalse; + } + else + { + return ETrue; + } + } + +// ----------------------------------------------------------------------------- +// TaskManagerImpl::RemovePersistentTask +// Removes task from persistent storage. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CTaskManagerImpl::RemovePersistentTask( const CTask& aTask ) + { + // Remove only if task is committed, i.e. it has an id. + if ( aTask.Id() ) + { + TFileName fileName; + GetTaskFilePath( fileName, aTask.Id() ); + iRFs.Delete( fileName ); + } + } + +// ----------------------------------------------------------------------------- +// TaskManagerImpl::DeleteTaskFilesL +// Deletes all tasks from persistent storage. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CTaskManagerImpl::DeleteTaskFilesL() + { + TFileName fileMatch; + GetTaskDir( fileMatch ); + fileMatch.Append( KTaskListMatch ); + + CFileMan* fileMan = CFileMan::NewL( iRFs ); + fileMan->Delete( fileMatch ); + delete fileMan; + } + +// ----------------------------------------------------------------------------- +// TaskManagerImpl::CreateTaskDirL +// Creates the directory where persistent tasks are stored. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CTaskManagerImpl::CreateTaskDirL() + { + TInt drive = 0; + iRFs.CharToDrive( TParsePtrC( PathInfo::PhoneMemoryRootPath() ).Drive()[0], drive ); + iRFs.CreatePrivatePath( drive ); + + TFileName taskDir; + GetTaskDir( taskDir ); + iRFs.MkDir( taskDir ); + } + +// ----------------------------------------------------------------------------- +// TaskManagerImpl::GetTaskDir +// Gets the directory where persistent tasks are stored. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CTaskManagerImpl::GetTaskDir( TDes& aFilePath ) + { + iRFs.PrivatePath( aFilePath ); + aFilePath.Insert( 0, TParsePtrC( PathInfo::PhoneMemoryRootPath() ).Drive() ); + aFilePath.Append( KTaskDir ); + } + +// ----------------------------------------------------------------------------- +// TaskManagerImpl::GetTaskFilePath +// Gets the full path to the persistent task file. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CTaskManagerImpl::GetTaskFilePath( TDes& aFilePath, TInt aTaskId ) + { + GetTaskDir( aFilePath ); + aFilePath.AppendNum( aTaskId ); + } + +// ----------------------------------------------------------------------------- +// TaskManagerImpl::PopulatePersistentTasksL +// Reads all persistent task from storage and populates the task list. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +void CTaskManagerImpl::PopulatePersistentTasksL() + { + // Get task dir matcher + HBufC* taskDir = HBufC::NewLC( KMaxFileName ); + TPtr dirPtr( taskDir->Des() ); + GetTaskDir( dirPtr ); + dirPtr.Append( KTaskListMatch ); + + // Get dir contents + CDir* dirList; + iRFs.GetDir( dirPtr, KEntryAttMaskSupported, ESortByDate, dirList ); + + if ( dirList ) + { + CleanupStack::PushL( dirList ); + + HBufC* taskPath = HBufC::NewLC( KMaxFileName ); + TPtr pathPtr( taskPath->Des() ); + GetTaskDir( dirPtr ); + + // Go through the list and internalize tasks + for ( TInt index = 0; index < dirList->Count(); index++ ) + { + pathPtr.Copy( dirPtr ); + pathPtr.Append( (*dirList)[index].iName ); + + // Create stream + RFileReadStream stream; + stream.PushL(); + User::LeaveIfError( stream.Open( iRFs, pathPtr, EFileRead ) ); + + // Internalize task + TUid uid; + uid.iUid = stream.ReadInt32L(); + CTask* task = CTask::NewL( uid, ETrue ); + stream >> *task; + iTaskList.Append( task ); + CleanupStack::PopAndDestroy(); // stream + } + + CleanupStack::PopAndDestroy( 2, dirList ); + } + CleanupStack::PopAndDestroy( taskDir ); + } + +// ----------------------------------------------------------------------------- +// TaskManagerImpl::GetFreeTaskIdL +// Gets the next free id that can be assigned to a task. +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +TInt CTaskManagerImpl::GetFreeTaskIdL() + { + TInt result( 0 ); + + // Get task dir matcher + HBufC* taskDir = HBufC::NewL( KMaxFileName ); + TPtr dirPtr( taskDir->Des() ); + GetTaskDir( dirPtr ); + dirPtr.Append( KTaskListMatch ); + + // Get dir contents + CDir* dirList; + iRFs.GetDir( dirPtr, KEntryAttMaskSupported, ESortByDate, dirList ); + delete taskDir; + + if ( dirList ) + { + // Find the first free slot + TInt index( 0 ); + while ( index < dirList->Count() ) + { + TBuf temp; + // Make sure that first index is 1 + temp.Num( index + 1 ); + if ( TParsePtrC( (*dirList)[index].iName ).Name() != temp ) + { + break; + } + ++index; + } + + delete dirList; + // Make sure that the first index is 1 + result = index + 1; + } + + return result; + } + +// End of File