/*
* 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:  Saves/restores current playback path
*
*/


#ifndef CMPXRESTOREPATH_H
#define CMPXRESTOREPATH_H

// INCLUDES
#include <e32base.h>
#include <mpxcollectionobserver.h>
#include <mpxplaybackobserver.h>

// CONSTANTS

// FORWARD DECLARATIONS
class CMPXAppUi;
class CMPXCollectionPath;
class MMPXCollectionUtility;
class MMPXPlaybackUtility;
class MMPXCollectionUiHelper;
class CMPXCollectionOpenUtility;

// CLASS DECLARATION
/**
 * Saves/restores current playback path.
 *
 *  @lib mpx.exe
 *  @since 3.1
 */
class CMPXRestorePath : public CBase,
                        public MMPXCollectionObserver,
                        public MMPXPlaybackObserver
    {
    public: // Constructors and destructor

        /**
         * Two-phased constructor.
         *
         * @since 3.1
         * @param aPlaybackUtility Playback utility to use.
         * @param aCollectionUiHelper UI helper to use
         * @return Pointer to newly created object.
         */
        static CMPXRestorePath * NewL(MMPXPlaybackUtility* aPlaybackUtility,
                                      MMPXCollectionUiHelper* aCollectionUiHelper);

        /**
         * Two-phased constructor.
         *
         * @since 3.1
         * @param aPlaybackUtility Playback utility to use.
         * @param aCollectionUiHelper UI helper to use
         * @return Pointer to newly created object.
         */
        static CMPXRestorePath * NewLC(MMPXPlaybackUtility* aPlaybackUtility,
                                       MMPXCollectionUiHelper* aCollectionUiHelper);

        /**
         * Destructor.
         */
        virtual ~CMPXRestorePath();

    public: // New funtions

        /**
         *  Loads current collection path
         */
        void LoadPathL();

        /**
         * Loads the default collection path
         * @param some delay to load the path (in ms)
         */
        void LoadDefaultPathL( TInt aDelay = 0 );

        /**
         * Save the current collection Path
         */
        void SavePathL();

        /**
         * Return if the default playlist has been initialized
         *
         * @return ETrue if the path has been initialized, EFalse otherwise;
         */
        TBool Initialized();

        /**
         * Return if the playlist is currently initializing
         *
         * @return ETrue it's currently initializing, EFalse otherwise;
         */
        TBool IsInitializing();

        /**
         * Set the initialized state
         *
         * @param aInit The current state of initialization.
         */
        void SetInitialized( TBool aInit );

        /**
         * Cancels the initialize operation
         */
        void CancelInit();
        
        /**
         * Get the Uid of the root path 
         */
        TUid RooPathId();

    private:

        /**
         * C++ Constructor
         *
         * @param aPlaybackUtility Playback utility to use.
         * @param aCollectionUiHelper collection ui helper to use
         */
        CMPXRestorePath (MMPXPlaybackUtility* aPlaybackUtility,
                         MMPXCollectionUiHelper* aCollectionUiHelper);

        /**
         * By default Symbian 2nd phase constructor is private.
         */
        void ConstructL();

    // from base class MMPXCollectionObserver

        /**
         * From MMPXCollectionObserver
         * Handle media properties.
         *
         * @since 3.1
         * @param aMedia  media properties.
         * @param aError Error code.
         */
        void HandleCollectionMediaL(
            const CMPXMedia& aMedia,
            TInt aError );

        /**
         * From MMPXCollectionObserver
         * Handle collection message.
         *
         * @since 3.1
         * @param aMessage Collection message
         * @param aErr system error code.
         */
        void HandleCollectionMessage(
            CMPXMessage* aMessage, TInt aError );

        /**
         * From MMPXCollectionObserver
         * Handles the collection entries being opened.
         *
         * @since 3.1
         * @param aEntries Collection entries opened.
         * @param aIndex Focused entry.
         * @param aComplete ETrue no more entries. EFalse more entries
         *                  expected.
         * @param aError Error code.
         */
        void HandleOpenL(
            const CMPXMedia& aEntries,
            TInt aIndex,
            TBool aComplete,
            TInt aError );

        /**
         * From MMPXCollectionObserver
         * Handles the item being opened.
         *
         * @since 3.1
         * @param aPlaylist Collection playlist, owner ship is transfered.
         * @param aError Error code.
         */
        void HandleOpenL(
            const CMPXCollectionPlaylist& aPlaylist,
            TInt aError );

        /**
         * From MMPXPlaybackObserver
         * Handle playback message
         *
         * @param aMessage playback message
         * @param aErr system error code.
         */
        void HandlePlaybackMessage( CMPXMessage* aMessage, TInt aError );

    private:  // New functions

        /**
         * Initialize playback engine with the path provided
         *
         * @param aPath The collection path to initialize playback engine with.
         */
        void InitPlaybackEngineL( CMPXCollectionPath& aPath );

        /**
         * Handle playback message
         *
         * @param aMessage playback message
         */
        void DoHandlePlaybackMessageL( const CMPXMessage& aMessage );

        /**
         * Handle collection message
         *
         * @param aMessage collection message
         */
        void DoHandleCollectionMessageL( const CMPXMessage& aMessage );

        /**
        * Start the incremental open operation at a particular index
        * @param aPath path to open
        * @param aIndex index to start reading from
        * @param aDelay delay to start the operation (in ms)
        */
        void DoIncrementalOpenL( CMPXCollectionPath& aPath, TInt aIndex,
                                 TInt aDelay = 0 );

    private:

        MMPXCollectionUtility* iCollectionUtility; // owned
        MMPXPlaybackUtility* iPlaybackUtility;  // not owned
        MMPXCollectionUiHelper* iCollectionUiHelper;  // not owned
        CMPXCollectionOpenUtility* iIncOpenUtil;

        TBool iPathInitialized;
        TBool iIsInitializing;
        TBool iInitCanceled;
        TBool iDefaultPath;      // Are we initializing the default path?
        TMPXItemId iSelectionId; // Item we want to play
        TInt  iSelectionIndex; // Index we are restoring to
        TBool iLoadSavedPath;    // Load a saved path or load a default path?
        TBool iUSBOngoing;       // is usb ongoing
        TUid iRootPathId;
        TBool iMTPStarted;      // is MTP started
    };

#endif // CMPXRESTOREPATH_H

// End of File