/*

* Copyright (c) 2002-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:  Calculates given folder size

*

*/

// INCLUDE FILES

#include "CFilemanagerActiveCount.h"

// CONSTANTS

const TInt KFileManagerProcessFilesPerCycle = 20;

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// CFileManagerActiveCount::CFileManagerActiveCount

// C++ default constructor can NOT contain any code, that

// might leave.

// -----------------------------------------------------------------------------

//

CFileManagerActiveCount::CFileManagerActiveCount( RFs& aFs ) :

    iFs( aFs ),

    iFolders( KErrNotFound ),

    iFiles( KErrNotFound),

    iOpenFiles( KErrNotFound )

    {

    }

// -----------------------------------------------------------------------------

// CFileManagerActiveCount::NewL

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

CFileManagerActiveCount* CFileManagerActiveCount::NewL( 

    RFs& aFs,

    const TDesC& aRootFolder,

    const CFileManagerItemProperties::TFileManagerFileType aType

    )

    {

    CFileManagerActiveCount* self = new( ELeave ) CFileManagerActiveCount( 

        aFs );

    CleanupStack::PushL( self );

    self->ConstructL( aRootFolder, aType );

    CleanupStack::Pop( self );

    return self;

    }

// -----------------------------------------------------------------------------

// CFileManagerActiveCount::ConstructL

// 

// -----------------------------------------------------------------------------

// 

void CFileManagerActiveCount::ConstructL( 

    const TDesC& aRootFolder,

    const CFileManagerItemProperties::TFileManagerFileType aType )

    {

    iDirScan = CDirScan::NewL( iFs );

    if ( aType == CFileManagerItemProperties::EFolder )

        {

        // Set scanning from current directory, take only folders

        // No sorting needed

        iDirScan->SetScanDataL(

            aRootFolder,

            KEntryAttDir | KEntryAttMatchExclusive,

            ESortNone );

        }

    else if ( aType == CFileManagerItemProperties::EFile ||

             aType == CFileManagerItemProperties::EOpen ||

             aType == CFileManagerItemProperties::EReadOnly )

        {

        // Set scanning from current directory, take only file

        // No sorting needed

        iDirScan->SetScanDataL(

            aRootFolder,

            KEntryAttNormal | KEntryAttHidden | KEntryAttSystem,

            ESortNone );

        }

    else

        {

        // Set scanning from current directory,

        // take file and folders except hidden and system files

        // No sorting needed

        iDirScan->SetScanDataL( aRootFolder, KEntryAttDir, ESortNone );

        }

    TRAPD( err, iDirScan->NextL( iDir ) );

    if ( err == KErrNone && iDir )

        {

        if ( aType == CFileManagerItemProperties::EOpen ||

             aType == CFileManagerItemProperties::EReadOnly )

            {

            iFiles = iDir->Count();

            iOpenFiles = 0;

            }

        else if ( aType == CFileManagerItemProperties::EFolder )

            {

            iFolders = iDir->Count();

            delete iDir;

            iDir = NULL;

            iProcessDone = ETrue;

            }

        else if ( aType == CFileManagerItemProperties::EFile )

            {

            iFiles = iDir->Count();

            delete iDir;

            iDir = NULL;

            iProcessDone = ETrue;

            }

        }

    }

// -----------------------------------------------------------------------------

// CFileManagerActiveCount::~CFileManagerActiveCount

// Destructor

// -----------------------------------------------------------------------------

// 

CFileManagerActiveCount::~CFileManagerActiveCount()

    {

    delete iDirScan;

    delete iDir;

    }

// -----------------------------------------------------------------------------

// CFileManagerActiveCount::IsProcessDone

// 

// -----------------------------------------------------------------------------

// 

TBool CFileManagerActiveCount::IsProcessDone() const

    {

    return iProcessDone;

    }

// -----------------------------------------------------------------------------

// CFileManagerActiveCount::StepL

// 

// -----------------------------------------------------------------------------

// 

void CFileManagerActiveCount::StepL()

    {

    if( !iDir )

        {

        iProcessDone = ETrue;

        return;

        }

    TInt processCount( KFileManagerProcessFilesPerCycle );

    while( iFileCounter < iDir->Count() && processCount )

        {

        const TEntry& entry( ( *iDir )[ iFileCounter ] );

        iFileName.Copy( iDirScan->FullPath() );

        iFileName.Append( entry.iName );

        TBool fileIsOpen( EFalse );

        if ( KErrNone == iFs.IsFileOpen( iFileName, fileIsOpen ) )

            {

            if ( fileIsOpen )

                {

                ++iOpenFiles;

                }

            }

        ++iFileCounter;

        --processCount;

        }

    if ( iFileCounter >= iDir->Count() )

        {

        delete iDir;

        iDir = NULL;

        iDirScan->NextL( iDir );

        if ( !iDir )

            {

            iProcessDone = ETrue;

            }

        iFileCounter = 0;

        }

    }

// -----------------------------------------------------------------------------

// CFileManagerActiveCount::FolderCount()

// 

// -----------------------------------------------------------------------------

// 

TInt CFileManagerActiveCount::FolderCount() const

    {

    if ( iProcessDone )

        {

        return iFolders;

        }

    return KErrNotFound;

    }

// -----------------------------------------------------------------------------

// CFileManagerActiveCount::FileCount()

//

// -----------------------------------------------------------------------------

//

TInt CFileManagerActiveCount::FileCount() const

    {

    if ( iProcessDone )

        {

        return iFiles;

        }

    return KErrNotFound;

    }

// -----------------------------------------------------------------------------

// CFileManagerActiveCount::OpenFiles()

//

// -----------------------------------------------------------------------------

//

TInt CFileManagerActiveCount::OpenFiles() const

    {

    if ( iProcessDone )

        {

        return iOpenFiles;

        }

    return KErrNotFound;

    }

// End of File