/*

* Copyright (c) 2007-2009 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:  SysAp drive list implementation

 *

*/

#ifndef SYSAPDRIVELIST_H

#define SYSAPDRIVELIST_H

// INCLUDES

#include <e32std.h>

#include "SysAp.hrh"

// FORWARD DECLARATIONS

class RFs;

// CLASS DECLARATION

class CSysApDriveList : public CBase

    {

public:

    /**

     * Two-phased constructor.

     */

    static CSysApDriveList* NewL( RFs& aFs );

    /**

     * Destructor

     */

    ~CSysApDriveList();

public: // New methods

    /**

    * Mounts drive

    *

    * @param aDrive Drive to mount

    * @return System wide error code

    */

    TInt MountDrive( TInt aDrive );

    /**

    * Dismounts drive

    *

    * @param aDrive Drive to dismount

    * @return System wide error code

    */

    TInt DismountDrive( TInt aDrive );

    /**

     * Updates drive state stored in the list

     *

     * @param aDrive Drive to update

     * @param aForceUpdate ETrue if forced update. Otherwise EFalse.

     */

    void UpdateDrive( TInt aDrive, TBool aForceUpdate );

    /**

     * Returns the status of the memory card

     *

     * @param aDrive Drive what status to get

     * @return The memory card status

     */

    TSysApMemoryCardStatus MemoryCardStatus( TInt aDrive );

    /**

     * Returns the drive id of default memory card

     */

    TInt DefaultMemoryCard() const;

    // For entry data used by GetMemoryCardsL

    class TMemoryCardEntry

        {        

        public:

            /**

             * Compare for RArray::Find()

             */

            static TInt CompareFind(

                const TInt* aDrive,

                const TMemoryCardEntry& aEntry );

        public:

            TInt iDrive;

            TSysApMemoryCardStatus iStatus;

            TUint iDriveStatus;

        };

    // For inclusition mask used by GetMemoryCardsL

    enum TMemoryCardInclusionMask

        {

        EIncludeAll = 0x0,

        EIncludeInserted = 0x1,

        EIncludeNonInserted = 0x2,

        EIncludeLocked = 0x4

        };

    /**

     * Gets the memory cards with requested status

     *

     * @param aDriveArray Array to store memory cards

     * @param aInclusionMask Memory card inclusion mask 

     *                       specified by TMemoryCardInclusionMask

     */

    void GetMemoryCardsL(

        RArray< TMemoryCardEntry >& aDriveArray,

        TUint aInclusionMask );

    /**

     * Gets the drive name with text formatting

     *

     * @param aDrive Drive that name is requested

     * @param aTextIdForDefaultName Text id containing %U

     * @param aTextIdForName Text id containing %0U and %1U

     * @return Pointer to allocated text

     */

    HBufC* GetFormattedDriveNameLC(

        const TInt aDrive,

        const TInt aTextIdForDefaultName,

        const TInt aTextIdForName = 0 ) const;

    /**

     * Returns drive index from given array or KErrNotFound if not found

     */

    static TInt Find(

        const RArray< TMemoryCardEntry >& aDriveArray,

        TInt aDrive );

    // Drive eject type used in MarkDriveToEject

    enum TDriveEjectType

        {

        EEjectNone = 0,

        EEjectFromMenu,

        EEjectRemovedWithoutEject

        };

    /**

     * Marks drive to be ejected

     */

    void MarkDriveToEject( TInt aDrive, TDriveEjectType aEjectUsed );

    /**

     * Resets drive marked to be ejected

     */

    void ResetDriveToEject( TInt aDrive );

    /**

     * Resets all drives marked to be ejected

     */

    void ResetDrivesToEject();

    /**

     * Gets next drive to be ejected, returns KErrNotFound if none marked

     */

    TInt DriveToEject( TDriveEjectType& aEjectUsed );

    /**

     * Checks is drive marked to be ejected

     */

    TBool IsDriveToEject( TInt aDrive );

    /**

     * Marks drive insert beeps to be ignored

     */

    void MarkDrivesInsertBeepIgnored( const RArray< TMemoryCardEntry >& aArray );

    /**

     * Mark drive insert beep to be ignored

     */

    void MarkDriveInsertBeepIgnored( TInt aDrive );

    /**

     * Resets drive insert beep marked to be ignored

     */

    void ResetDriveInsertBeepIgnored( TInt aDrive );

    /**

     * Resets all drives marked inserts beeps

     */

    void ResetDrivesInsertBeepIgnored();

    /**

     * Checks is insert beep ignored

     */

    TBool IsDriveInsertBeepIgnored( TInt aDrive );

    /**

     * Marks locked drive's unlock query status as shown

     */

    void MarkDriveUnlockQueryShown( TInt aDrive );

    /**

     * Resets locked drive's unlock query shown status

     */

    void ResetDriveUnlockQueryShown( TInt aDrive );

    /**

     * Gets next locked drive to be unlocked. Returns KErrNotFound if none.

     * The locked drives where unlock query has been shown are ignored.

     */

    TInt DriveToUnlock();

    /**

     * Returns number of non USB drives in the array

     */

    static TInt NonUsbDriveCount( const RArray< TMemoryCardEntry >& aDriveArray );

private:

    /**

    * Constructors.

    */

    CSysApDriveList( RFs& aFs );

    void ConstructL();

    // Used internally for drive states

    enum TDriveState

        {

        EStateStatusUpdated = 0x1,

        EStateEjectedFromMenu = 0x2,

        EStateRemovedWithoutEject = 0x4,

        EStateBeepIgnored = 0x8,

        EStateUnlockQueryShown = 0x10,

        EStateAllEjected = EStateEjectedFromMenu | EStateRemovedWithoutEject

        };

    // Used internally for drive status caching

    class TDriveStateEntry

        {

        public:

            TSysApMemoryCardStatus iStatus;

            TUint iState;

            TUint iDriveStatus;

        };

private: // Data

    // Reference to open file server session

    RFs& iFs;

    // The default memory card drive

    TInt iDefaultMemoryCard;

    // Array for drive state caching

    TFixedArray< TDriveStateEntry, KMaxDrives > iStatusCache;

    };

#endif // SYSAPDRIVELIST_H

// End of File