/*

* Copyright (c) 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:  Engine for rendering images remotely

*

*/

#ifndef UPNP_IMAGERENDERINGENGINE_H

#define UPNP_IMAGERENDERINGENGINE_H

// INCLUDES

#include <e32base.h>

#include "upnpavrenderingsessionobserver.h" // base class

#include "upnpitemresolverobserver.h" // base class

#include "upnprenderingstatemachineobserver.h" // base class

// FORWARD DECLARATIONS

class MUPnPAVController;

class MUPnPAVRenderingSession;

class MUpnpImageRenderingEngineObserver;

class MUPnPItemResolver;

class CUpnpRenderingStateMachine;

class CUPnPPeriodic;

/**

* This class defines the UpnpShowTask used in UpnpCommand component.

*

* @since S60 3.2

*/

class CUpnpImageRenderingEngine

    : public CBase

    , public MUPnPItemResolverObserver

    , public MUPnPAVRenderingSessionObserver

    , public MUpnpRenderingStateMachineObserver

    {

    public: // construction

        /**

         * static constructor

         * @param aAVController avcontroller resource

         * @param aSession the rendering session to work with

         * @param aObserver the client for this engine

         */

        static CUpnpImageRenderingEngine* NewL(

            MUPnPAVController& aAVController,

            MUPnPAVRenderingSession& aSession,

            MUpnpImageRenderingEngineObserver& aObserver);

        /**

         * destructor

         */

        virtual ~CUpnpImageRenderingEngine();

    private: // private part of construction

        /**

         * constructor

         */

        CUpnpImageRenderingEngine(

            MUPnPAVController& aAVController,

            MUPnPAVRenderingSession& aSession,

            MUpnpImageRenderingEngineObserver& aObserver);

        /**

         * Second phase constructor

         */

        void ConstructL();

    public: // the interface

        /**

         * Requests to start rendering. This will cause the engine to query

         * the media to render using the callback interface.

         * This method can be called in all states and all conditions

         * and subsequently very fast. The engine will keep track of

         * states and indicate errors etc.

         */

        void PlayL();

        /**

         * Requests to stop rendering.

         */

        void StopL();

    protected: // Call back methods of MUPnPAVRenderingSessionObserver

        /**

         * UPnP AV Controller calls this method to return the result for the

         * 'set uri' request.

         *

         * @since Series 60 3.1

         * @param aError error code

         * @return None

         */

        void SetURIResult( TInt aError );

        /**

         * UPnP AV Controller calls this method to indicate that the requested

         * interaction operation (play, stop, etc.) is complete. In other

         * words, the target rendering device has changed it's state 

         * accordingly.

         *

         * @since Series 60 3.1

         * @param aError (TInt) error code

         * @param aOperation (TAVInteractOperation) operation Id

         */

        void InteractOperationComplete( TInt aError,

            TUPnPAVInteractOperation aOperation );

        /**

         * Notifies that the Media Renderer we have a session with has

         * disappeared. Session is now unusable and must be closed. 

         *

         * @since Series 60 3.1

         * @param aReason (TUPnPDeviceDisconnectedReason) reason code

         */

        void MediaRendererDisappeared(

            TUPnPDeviceDisconnectedReason aReason );

        // Methods that are not used

        void VolumeResult(

                        TInt /*aError*/,

                        TInt /*aVolumeLevel*/,

                        TBool /*aActionResponse*/) {}

        void MuteResult(

                        TInt /*aError*/,

                        TBool /*aMute*/,

                        TBool /*aActionResponse*/ ) {}

        void PositionInfoResult(

                        TInt /*aError*/,

                        const TDesC8& /*aTrackPosition*/,

                        const TDesC8& /*aTrackLength*/ ) {}

        void SetNextURIResult(

                        TInt /*aError*/ ) {}

        void ReserveLocalMSServicesCompleted( TInt /*aError*/ ) {}

    protected: // Methods from MUPnPItemResolverObserver

        /**

         * See UpnpAvControllerHelper API for more info.

         */

        void ResolveComplete(

            const MUPnPItemResolver& aResolver, TInt aError );

    protected: // from MUpnpRenderingStateMachineObserver

         /**

          * Indicates state machine has been synchronised with the renderer

          *

          * @since Series 60 3.2

          * @param aError error that occurred during sync

          */

        void RendererSyncReady( TInt aError,

                            Upnp::TState aState );

        /**

         * Indicates renderer state has changed either by request 

         * or spontanelously.

         *

         * @since Series 60 3.2

         * @param aError the error code

         * @param aState the new state

         * @param aUserOriented ETrue if this responds to a request

         * @param aStateParam extra info depending on the state change

         */

        void RenderingStateChanged(

                            TInt aError,

                            Upnp::TState aState,

                            TBool aUserOriented,

                            TInt aStateParam );

        /**

         * Synchronises UI with media duration and current position

         * this callback can be either automatic or explicitly requested

         *

         * @since Series 60 3.2

         * @param aError error that occurred during position sync

         * @param aMode mode in which the track is progressing

         * @param aDuration media duration in milliseconds

         * @param aPosition current position in milliseconds

         */

        void PositionSync( TInt aError,

                            Upnp::TPositionMode aMode,

                            TInt aDuration, TInt aPosition );

    public: // methods for the timer

        /**

         * the timeout callback

         */

        static TInt Timer( TAny* aArg );

        /**

         * handles the timeout internally

         */

        void RunTimerL();

        /**

         * handles errors in the timeout callback body

         */

        TInt RunError( TInt aError );

         /**

          * checks if wlan is active

          */

        TBool IsWlanActive();

    private: // Private methods

        /**

         * Handles the start up of the item resolving.

         *

         * @since S60 3.2

         * @param none

         * @return none

         */

        void StartResolvingL();

        /**

         * Sends an acknowledgement

         *

         * @since S60 3.2

         * @param aError error code

         * @return none

        */

        void SendRenderAck( TInt aError );

        /**

         * Cycles next item by checking resolver status

         *

         * @since S60 3.2

         * @param none

         * @return none

         */

        void Cycle();

        /**

         * Cleans up used resources

         *

         * @since S60 3.2

         * @param none

         * @return none

         */

        void Cleanup();

    private: // Data members

        // avcontroller

        MUPnPAVController&                  iAVController;

        // the rendering session

        MUPnPAVRenderingSession&            iRenderingSession;

        // The observer interface

        MUpnpImageRenderingEngineObserver&  iObserver;

        // internal states

        enum TRenderingState

            {

            EIdle = 100,     // doing nothing

            EResolvingItem,  // resolving (preparing the item to be played)

            EResolveComplete,// resolve done succesfully. Starting to play

            ERendering,      // Check accurate state from statemachine

            EShuttingDown

            };

        // internal state

        TRenderingState                     iState;

        // current resolver. owned.

        MUPnPItemResolver*                  iCurrentResolver;

        // Buffered next resolver. Owned.

        MUPnPItemResolver*                  iBufferedResolver;

        // flag that indicates a new image is in buffer

        TBool                               iBufferingNewImage;

        // timer support

        CUPnPPeriodic*                      iTimer;

        // Flag if WLan active or not

        TBool                               iWlanActive;

        // the rendering state machine

        CUpnpRenderingStateMachine*         iRenderingStateMachine;

    };

#endif // UPNP_IMAGERENDERINGENGINE_H

// End of File