/*

* Copyright (c) 2007 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

// FORWARD DECLARATIONS

class MUPnPAVController;

class MUPnPAVRenderingSession;

class MUpnpImageRenderingEngineObserver;

class MUPnPItemResolver;

class CUPnPPeriodic;

/**

* This class defines the UpnpShowTask used in UpnpCommand component.

*

* @since S60 3.2

*/

class CUpnpImageRenderingEngine

    : public CBase

    , public MUPnPItemResolverObserver

    , public MUPnPAVRenderingSessionObserver

    {

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

        /**

         * Cleans up used resources

         */

        void Cleanup();

    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. This method can be called in all states.

         */

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

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

         /**

         * checks if wlan is active

         */       

        TBool IsWlanActive();

    private: // Private methods

        /**

         * Handles the initiation of rendering (SetUri or video player 

         * launching).

         *

         * @since S60 3.2

         */

        void InitiateShowingL();

        /**

         * Handles the start up of the item resolving.

         *

         * @since S60 3.2

         */

        void StartResolvingL();

        /**

         * Sends an acknowledgement

		 */

		void SendRenderAck( TInt aError );

    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

            EStopping,              // calling Stop (for previoysly playing item)

            ESettingUri,            // calling SetAVTransportURI

            EStartingPlay,          // calling Play

            EPlaying,               // play OK, just displaying the image :-)

            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;

		TBool                       iWlanActive;

	};

#endif // UPNP_IMAGERENDERINGENGINE_H

// End of File