/*

* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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:    Helper class for Video Center for drive operations/monitoring.*

*/

#ifndef CIPTVDRIVEMONITOR_H

#define CIPTVDRIVEMONITOR_H

//  INCLUDES

#include <e32base.h>

#include <f32file.h>

#include "TIptvDriveInfo.h"

#include "TIptvDriveMonitorEvent.h"

#include "MIptvDriveMonitorObserver.h"

#include "IptvDebug.h"

// CONSTANTS

// MACROS

// DATA TYPES

// FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

// CLASS DECLARATION

/**

 * Helper class for Video Center for drive operations/monitoring.

 * User can get available drives (through iAvailableDrives public member)

 * and be notified when drives change (through MIptvDriveMonitorObserver interface).

 */

NONSHARABLE_CLASS (  CIptvDriveMonitor ) : public CActive

    {                

    public:  // Constructors and destructor

        /**

        * Two-phased constructor.

        */

        static CIptvDriveMonitor* NewL();

        /**

        * Two-phased constructor. Use this is owner object already has a file session open.

        *

        * @param aFileSession file session.

        */

        static CIptvDriveMonitor* NewL( const RFs& aFileSession );

        /**

        * Destructor.

        */

        virtual ~CIptvDriveMonitor();

    public:

        /**

        * Registers observer for drive events.

        * iAvailableDrives is updated automatically if there are any

        * observers registered, ie there is no need to call RefreshAvailableDrivesL

        * when observing.

        * Don't keep observers around if they do not need events. Observing should be used

        * when user needs to know immedetially about memory card insertion/removed events,

        * or drive locked/unlocked events.

        *

        * @param aObserver observer, ownership does not move.

        */

        void RegisterObserverL( MIptvDriveMonitorObserver* aObserver );

        /**

        * Removes observer, ownership does not move.

        * @param aObserver observer to be removed from observers list.

        */ 

        void RemoveObserverL( MIptvDriveMonitorObserver* aObserver );

        /**

        * Updates iAvailableDrives member variable from File server.

        * This is called in ConstructL() also.

        */ 

        void RefreshAvailableDrivesL();

        /**

        * Returns the position index of aDrive in iAvailableDrives.

        *

        * @param aDrive drive to search.

        * @return Position index of aDrive in iAvailableDrives. If not found,

        *         KErrNotFound is returned.

        */        

        TInt ArrayPos( TInt aDrive );

        /**

        * Returns the position index of aDrive in iAvailableDrives. If not

        * found, leaves with KErrNotFound code.

        *

        * @param aDrive drive to search.

        * @return Position index of aDrive in iAvailableDrives.

        */        

        TInt ArrayPosL( TInt aDrive );

        /**

        * Returns the default removable drive (= memory card drive) from iAvailableDrives

        * array. Leaves with KErrNotFound if not found.

        */        

        TInt MemoryCardDriveL();

        /**

        * Returns the default removable drive (= memory card drive) from iAvailableDrives

        * array. Returns KErrNotFound if not found.

        *

        * @return drive number, or KErrNotFound if not found.

        */        

        TInt MemoryCardDrive();

        /**

        * Returns the default mass memory drive if found from iAvailableDrives.

        * Mass storege drive means the drive which is preferred for storing large

        * files in the device, the drive itself can be anything, usually not c though.

        * Leaves with KErrNotFound if not found.

        *

        * @return Drive number.

        */

        TInt MassStorageDriveL();

        /**

        * Returns the default mass memory drive if found from iAvailableDrives.

        * Mass storege drive means the drive which is preferred for storing large

        * files in the device, the drive itself can be anything except c-drive.

        * Returns KErrNotFound if not found.

        *

        * @return Drive number, or KErrNotFound if not found.

        */

        TInt MassStorageDrive();

        /**

        * Returns the phone memory drive from iAvailableDrives array.

        * Leaves with KErrNotFound if not found.

        *

        * @return Drive number.

        */

        TInt PhoneMemoryDriveL();

        /**

        * Returns the PhoneMemory drive from iAvailableDrives array.

        * Returns KErrNotFound if not found.

        *

        * @return Drive number, or KErrNotFound if not found.

        */

        TInt PhoneMemoryDrive();

        /**

        * Returns the first fixed (= non removable) drive from iAvailableDrives array.

        * Leaves with KErrNotFound if not found.

        *

        * @param aExcludeCDrive If ETrue, then C-drive is excluded.

        * @return Drive number.

        */

        TInt FixedDriveL( TBool aExcludeCDrive );

        /**

        * Returns the first fixed (= non removable) drive from iAvailableDrives array.

        * Returns KErrNotFound if not found.

        *

        * @param aExcludeCDrive If ETrue, then C-drive is excluded.

        * @return Drive number, or KErrNotFound if not found.

        */

        TInt FixedDrive( TBool aExcludeCDrive );

        /**

        * @return ETrue if aDrive is the preferred mass storage drive for the large files.

        */

        TBool IsMassStorageDriveL( TInt aDrive );

        /**

        * @return ETrue if aDrive is memory card type.

        */

        TBool IsMemoryCardDriveL( TInt aDrive );

        /**

        * @return ETrue media is present in the drive. (Memory card is inserted and drive is not locked).

        */

        TBool IsPresentL( TInt aDrive );

        /**

        * @return The system drive. Might not be in iAvailableDrives.

        */

        TInt SystemDrive();

        /**

        * Finds out if memory card is inserted and not locked.

        *

        * @return Returns ETrue is memory card is inserted and usable (not locked), EFalse otherwise.

        */

        TBool IsMmcInserted();

        /**

        * Gets the used memory from cenrep. If cenrep contains invalid drive or value is not found,

        * chooses the preferred drive in the following order: 1. mass storage 2. memory card

        * 3. EDriveC. If cenrep value was not usable, the chosen drive is written to cenrep.

        * Leaves with system-wide error code if wasn't able to get the used memory.

        *

        * @param aUsedMemory The used memory drive is written here.

        */        

        void GetUsedMemoryL( TInt& aUsedMemory );

    protected: // Functions from base classes

        /**

        * From CActive, RunL.

        * Called when operation completes.

        */

        void RunL();

        /**

        * From CActive, cancels request.

        */

        void DoCancel();

        /**

        * From CActive, handles leaves from RunL.

        */

        TInt RunError( TInt aError );

    private:

        /**

        * C++ default constructor.

        */

        CIptvDriveMonitor();

        /**

        * By default Symbian 2nd phase constructor is private.

        */

        void ConstructL();

        /**

        * By default Symbian 2nd phase constructor is private.

        *

        * @param aFileSession

        */

        void ConstructL( const RFs& aFileSession );

        /**

        * Sends event to observers.

        *

        * @param aEvent event to send.

        * @param aDrive drive which caused the event.

        */

        void SendEvent( TIptvDriveMonitorEvent::TEvent aEvent, TInt aDrive );

        /**

        * Compares iPreviousAvailableDrives and iAvailableDrives arrays and

        * sends appropriate events if they differ.

        */

        void CompareOldAndNewAvailableDrives();

        /**

        * Returns drive type as a descriptor. For debugging only.

        * @param aType Drive type, see valid values from e32const.h TMediaType enum.

        */

        const TDesC& DriveTypeDes( TInt aType );

        /**

        * Prints available drives. For debugging only.

        */

        void PrintAvailableDrives();

    public:

        /**

        * Array of currently available drives. These are updated

        * with RefreshAvailableDrivesL -method or from file

        * server event. RefreshAvailableDrivesL is also called upon creation

        * of this object.

        * iAvailableDrives array contains drives which are available for mass

        * storaging videos. If there is hard disk and memory card

        * available(both e and f-drives), then c-drive is excluded from the array.

        */

        RArray<TIptvDriveInfo> iAvailableDrives;

    private:

        /**

        * Used to detect if refresh had any effect.

        */

        RArray<TIptvDriveInfo> iPreviousAvailableDrives;

        /**

        * Array of observers. Pointers not owned.

        */

        RArray<MIptvDriveMonitorObserver*> iObservers;

        /**

        * Session to file server.

        */

        RFs iFs;

        /**

        * ETrue if iFs is provided by the user of this class.

        */

        TBool iIfsIsProvidedByUser;

        /**

        * Default memory for storing large files.

        */

        TInt iDefaultMassStorageDrive;

        /**

        * Default memory card.

        */

        TInt iDefaultMemoryCardDrive;

        /**

        * System drive.

        */

        TInt iSystemDrive;

    };

#endif      // CIPTVDRIVEMONITOR_H   

// End of File