/*
* 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:  Initialize a file before playback
*
*/


#ifndef CMPXPLAYBACKINITIALIZER_H
#define CMPXPLAYBACKINITIALIZER_H

#include <mpxplaybackframeworkdefs.h>
#include <mpxplaybackpluginobserver.h>
#include <mpxpluginhandlerobserver.h>
#include <mpxcollectionobserver.h>

class CMPXPlaybackPluginHandler;
class CMPXCollectionPlaylist;
class CMPXPlaybackEngine;
class CMPXPlaybackPluginHandler;
class CMPXPlaybackPlugin;
class CMPXPlaybackMediaHelper;

/**
*  Initializes playlist to be played. This class is a friend
*  of CMPXPlaybackEngine
*
*  The use of this class is intended to be as follows by the
*  playback engine:
*  1) The Engine creates initializer class and initializes it with a
*     CMPXCollectionPlaylist.
*  2) This initializer will then request the media.
*  3) The Engine then calls SetActive(), which means the Engine is now
*     active, so that means the resultant media request will be forwarded
*     directly to the Engine.
*  4) The Engine can then call Next() anytime afterwards.  This will
*     make the initializer call request media on the next item in the playlist.
*  5) Once the media returns to the initializer, it will create a playback
*     plugin and initialize the file
*  6) Once initialized, the plugin stays in the initialized state.  If the
*     Engine then calls SetActive() again, the plugin and all data will
*     be swapped, and then the Engine can start playing immediately.
*
*  At anytime during the process (e.g. during request media, during
*  initialization, etc), the Engine can interrupt the process and call
*  SetActive(), which will swap any plugins or data appropriately, depending
*  on the current state.
*
*/
class CMPXPlaybackInitializer : public CBase,
                                public MMPXPlaybackPluginObserver,
                                public MMPXPluginHandlerObserver
    {
public:
    /**
     *  Two-phased constructor.
     *
     *  @param aEngine reference to engine
     *  @param aMediaHelper Media helper object
     *  @return Constructed object
     */
    static CMPXPlaybackInitializer* NewL(
        CMPXPlaybackEngine& aEngine,
        CMPXPlaybackMediaHelper& aMediaHelper );

    /**
     *  Destructor
     */
    ~CMPXPlaybackInitializer();

    /**
    * Start intializing first media in the playlist.
    * Clears any current playlist being processed
    */
    void Init(CMPXCollectionPlaylist& aPlaylist);

    /**
    * Initializes next track in playlist. Discards current
    * track being processed
    */
    TBool Next();

    /**
    * Set the playlist active in the engine. Subsequently,
    * the next track or a new playlist can be initialized
    */
    void SetActiveL();

    /**
    * Close the initializer
    */
    void Close();

    /**
    * Return the TMPXItemId of the current file in the initializer
    */
    TMPXItemId CurrentInitItemId();

    /**
     * Implementation uid of the plugin of pre-initialzer
     */
    TUid PluginUid();
    
private:
    /**
    *  C++ constructor
    *
    *  @param aEngine reference to engine
    *  @param aMediaHelper Media helper object
    */
    CMPXPlaybackInitializer(
        CMPXPlaybackEngine& aEngine,
        CMPXPlaybackMediaHelper& aMediaHelper );

    /**
    *  2nd phase contructor
    */
    void ConstructL();

    /**
    * Resets such that next media can be initialised
    */
    void Reset();

    /**
    * Get the Media from the collection - the callback triggers
    * the initialization
    */
    void RequestMediaL();

    /**
    * Updates the forwarding variable
    * to send the media to the engine if a media has been requested.
    */
    void UpdateMediaForwarding();

    /**
    * Swaps the plugin being handled in the initializer to the
    * engine, which takes over in whatever state it currently is in.
    */
    void SwapPluginL();

    /**
    * Swaps the item uri in the engine
    * Only in the EPbStateInitialising and EPbStateStopped states
    */
    void SwapUriL();

    /**
    * Swaps the item db flag in the engine
    * Only in the EPbStateInitialising and EPbStateStopped states
    */
    void SwapFlag();

    /**
    * Is this playlist the one currently being processed?
    * @param aPlaylist Playlist to check if it is already initialized
    */
    TBool IsInitializing(const CMPXCollectionPlaylist& aPlaylist);

    /**
    * Initializes a track
    * @param aMedia CMPXMedia object to initialize
    * @param aError Error returned from media request
    */
    void InitL(const CMPXMedia& aMedia,TInt aError);

    /**
    * Cancels the pre-init timer
    */
    void CancelPreInitTimer();

    /**
    * Handle pre-init timer callback
    */
    void HandlePreInitTimerCallback();

    /**
    * Callback for pre-init timer.
    */
    static TInt PreInitTimerCallback(TAny* aPtr);

    /**
     * Initialize streaming
     */
    void InitL(const TDesC& aUri, const TDesC8& aType, TInt aAccessPoint);
    
private:
    /**
     *  From MMPXPlaybackPluginObserver
     *  Handle plugin event
     *
     *  @param aEvent the event type
     *  @param aData optional data
     *  @param aError error code of the event
     */
    void HandlePluginEvent(TEvent aEvent,TInt aData,TInt aError);

    /**
     *  Leaving version of CMPXPlaybackInitializer::HandlePluginEvent
     */
    void HandlePluginEventL(TEvent aEvent,TInt aData,TInt aError);

    /**
     * From MMPXPlaybackPluginObserver
     * Handle message from plug-in
     *
     * @param aMsg, message from the plug-in. Ownership not transferred.
     * @param aErr system error code. if aErr is not KErrNone, aMsg will not be
     *        used/dereferenced at playback engine.
     */
    void HandlePlaybackMessage(CMPXMessage* aMsg, TInt aErr);

    /**
     *  From MMPXPlaybackPluginObserver
     *  Async response for Value request
     *
     *  @param aProperty property key
     *  @param aValue property value
     *  @param aError error code
     */
    void HandleProperty(TMPXPlaybackProperty aProperty,
                         TInt aValue,TInt aError);

    /**
     *  From MMPXPlaybackPluginObserver
     *  Async response for subplayer request
     *
     *  @param aPlayer UID of the subplayer
     *  @param aSubPlayers array of subplayers
     *  @param aComplete ETrue, completed, EFalse, not completed
     *  @param aError error code
     */
    void HandleSubPlayerNames(TUid aPlayer,const MDesCArray* aSubPlayers,
                               TBool aComplete,TInt aError);

    /**
     *  From MMPXPlaybackPluginObserver
     *  Async response for ExtendedMediaProperties request
     *
     *  @param aMedia property object
     *  @param aError error code
     */
    void HandleMedia(const CMPXMedia& aProperties,TInt aError);

    ///////////////////////////////////////////////////////////////////////////
    // From MMPXPluginHandlerObserver

    /*
    * @see MMPXPluginHandlerObserver
    */
    void HandlePluginHandlerEvent(TPluginHandlerEvents aEvent,
        const TUid& aPluginUid, TBool aLoaded, TInt aData);

private:
    TMPXPlaybackState iState; // State of playlist
    CMPXPlaybackPluginHandler* iHandler;
    CMPXPlaybackEngine& iEngine;
    CMPXPlaybackMediaHelper& iMediaHelper;  // not owned

    TInt iPathIndex;
    TInt iInitPlaylistCount;
    TBool iMediaToEngine;
    TBool iMediaRequested;

    TInt iDuration;
    TInt iError;
    CMPXMedia* iMedia;
    CMPXMessage* iMediaMessage; // media update message from plugin
    TInt iErrorOfMediaMessage; // error along with media update message
    CPeriodic* iTimer;
    };

#endif // CMPXPLAYBACKINITIALIZER_H