/*

* 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: 

*     The actual "engine". 

*

*/

#ifndef CMSENG_H

#define CMSENG_H

// SYSTEM INCLUDES

#include <data_caging_path_literals.hrh>

#include <badesca.h>                        // descriptor arrays

#include <f32file.h>                        // enum TDriveNumber

#include <stringresourcereader.h>

#include <barsc2.h>                         // CResourceFile

#include <barsread2.h>                      // RResourceReader

// USER INCLUDES

#include "msenguihandler.h"

// FORWARD DECLARATIOS

class CMsengScanner;

class RFs;

class MMsengUIHandler;

// CONSTANTS

// Resource file path

_LIT(KMsengRscFilePath,"Z:mseng.rsc");

// DATA TYPES

/**

*  Type definition to handle arrays of integers 

*  more conveniently

*/

typedef CArrayFixFlat<TInt> CIntArray;

// CLASS DECLARATION

/**

*  The actual "engine".

*  This is the class which the UI instantiates.

*/

class CMseng :public CBase

    {

    public:  // Constructors and destructor

        /**

        * Two-phased constructor.

        * @param aUIHandler Reference to a class implementing MMsengUIHandler interface

        */

        IMPORT_C static CMseng* NewL(MMsengUIHandler& aUIHandler);

        /**

        * Destructor.

        */

        IMPORT_C ~CMseng();

    public: // New functions

        /**

        * Get the data groups.

        * @return CDesCArray* containing the names of the data groups.

        */

        IMPORT_C CDesCArray* DataGroupsL() const;

        /**

        * Get the scan result. This array contains exacly one

        * integer per data group. 

        * @return Array of integers. 

        */

        IMPORT_C CArrayFix<TInt64>* ScanResultL() const;

        /**

        * Is there scanning going on?

        * @return ETrue if there is scanning going on, otherwise EFalse.

        */

        IMPORT_C TBool ScanInProgress() const;

        /**

        * Get the amount of total and free space on a disk

        * @param aTotal Amount of total space in bytes in substituted here.

        * @param aFree Amount of free space in bytes in substituted here.

        * @param aVolume Disk identifier, e.g. 'C'

        */

        IMPORT_C void DiskInfoL(TInt64& aTotal, TInt64& aFree, const TDriveNumber aVolume) const;

        /**

        * Get the amount of total and free RAM.

        * @param aTotal Amount of total RAM in bytes in substituted here.

        * @param aTotal Amount of free RAM in bytes in substituted here.

        */

        IMPORT_C static void MemInfoL(TInt64& aTotal, TInt64& aFree);

        /**

        * Start scanning memory. 

        * This means starting the actual work of the engine. Starts scanning,

        * which runs until finished.

        *

        * The scanning is only supported for drives C and E, otherwise

        * leave occurs with error KErrNotSupported.

        *        

        * NOTE: the support for scanning E drive is not properly tested.

        *       It is assumed to have the same directory structure than in C.

        *

        * @param aDrive the drive to be scanned

        */

        IMPORT_C void ScanL(TDriveNumber aDrive);

        /**

        * Cancel ongoing scanning operation.

        */

        IMPORT_C void Cancel();

        /**

        * Check whether internal drive.

        * @param aDrv Drive to be checked.

        * @return ETrue if internal drive, otherwise EFalse.

        */

        static TBool IsInternalDrive( RFs& aFs, const TInt aDrv );

        /**

        * Check whether removable drive.

        * @param aDrv Drive to be checked.

        * @return ETrue if internal drive, otherwise EFalse.

        */

        static TBool IsRemovableDrive( RFs& aFs, const TInt aDrv );

        /**

        * Check whether mass storage drive.

        * @param aDrv Drive to be checked.

        * @return ETrue if mass storage drive, otherwise EFalse.

        */

        static TBool IsMassStorageDrive( RFs& aFs, const TInt aDrv );

    private:

        /**

        * C++ default constructor is prohibited.

        */

        CMseng(MMsengUIHandler& aUIHandler);

        /**

        * By default Symbian OS constructor is private.

        *

        * Initialize iResultArray by reading the the data group 

        *  names from resource file and setting all result values to zero.

        * Initialize iDataGroupUidArray and iDataGroupExtArray

        *  from resource file.

        */

        void ConstructL();

        // Prohibit copy constructor if not deriving from CBase.

        CMseng( const CMseng& );

        // Prohibit assigment operator if not deriving from CBase.

        CMseng& operator= ( const CMseng& );

    private:    // Data members

        MMsengUIHandler& iUIHandler;

        CMsengScanner* iScanner;

        // Number of data groups

        TInt iNumberOfDataGroups;

        // These arrays are needed to when calculating the result.

        // They are indexed using values from enum TDataGroups.

        // This creates the mapping between data groups and the

        // UIDs and extensions belonging to a particular data group

        CArrayPtrFlat<CIntArray>* iDataGroupUidArray;

        CArrayPtrFlat<CIntArray>* iDataGroupExtArray;        

        RFs iFsSession;

        CResourceFile* iResFile;

        mutable TInt64 iFreeMemory;        

    };

#endif      // CMSENG_H   

// End of File