/*

* Copyright (c) 2008 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 drive operations/monitoring.*

*/

#ifndef VCXMYVIDEOSDRIVEMONITOR_H

#define VCXMYVIDEOSDRIVEMONITOR_H

//  INCLUDES

#include <e32base.h>

#include <f32file.h>

#include "vcxmyvideosdriveinfo.h"

#include "vcxmyvideosdrivemonitorevent.h"

// CLASS DECLARATION

/**

* Observer for CVcxMyVideosDriveMonitor class.

*/

NONSHARABLE_CLASS(MVcxMyVideosDriveMonitorObserver)

    {

    public:

        /**

        * Handles drive monitor event.

        *

        * @param aEvent Event.

        */

        virtual void HandleDriveMonitorEvent( TVcxMyVideosDriveMonitorEvent& aEvent ) = 0;

    };

/**

 * Helper class for drive operations/monitoring.

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

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

 */

NONSHARABLE_CLASS(CVcxMyVideosDriveMonitor) : public CActive

    {                

    public:  // Constructors and destructor

        /**

        * Two-phased constructor.

        */

        static CVcxMyVideosDriveMonitor* NewL();

        /**

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

        *

        * @param aFileSession file session.

        */

        static CVcxMyVideosDriveMonitor* NewL( const RFs& aFileSession );

        /**

        * Destructor.

        */

        virtual ~CVcxMyVideosDriveMonitor();

    public:

        /**

        * 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 first removable drive (= memory card drive) from iAvailableDrives

        * array. Leaves with KErrNotFound if not found.

        */        

        TInt MemoryCardDriveL();

        /**

        * Returns the first 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 first mass storage drive from iAvailableDrives array.

        * 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 first mass storage drive from iAvailableDrives array.

        * 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();

        /**

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

        * The returned memory might be locked or not present. Use GetUsedMemoryL to get drive

        * which is available for usage.

        *

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

        */        

        void GetPreferredMemoryL( TInt& aPreferredMemory );

        /**

        * Gets a memory for usage. Tries first the preferred memory, if it is not

        * available (locked or not present), tries the next drive from iAvailable drives.

        * if suitable drive is not found, returns system drive (c-drive).

        *

        * @param aUsedMemory  Drive which should be used 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.

        */

        CVcxMyVideosDriveMonitor();

        /**

        * 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( TVcxMyVideosDriveMonitorEvent::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.

        * Array contains also drives which don't have media present (mmc), or which

        * are locked.

        */

        RArray<TVcxMyVideosDriveInfo> iAvailableDrives;

    private:

        /**

        * Used to detect if refresh had any effect.

        */

        RArray<TVcxMyVideosDriveInfo> iPreviousAvailableDrives;

        /**

        * Array of observers. Pointers not owned.

        */

        RArray<MVcxMyVideosDriveMonitorObserver*> iObservers;

        /**

        * Session to file server.

        */

        RFs iFs;

        /**

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

        */

        TBool iIfsIsProvidedByUser;

    };

#endif      // VCXMYVIDEOSDRIVEMONITOR_H   

// End of File