/*
* 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 <s32file.h>
#include <pathinfo.h>

#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<KMaxNumLength> 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