/*

* 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

*

*/

// INCLUDE FILES

// upnp stack api

#include <upnpitem.h>                   // CUpnpItem

#include <upnpobject.h>                 // CUpnpObject (cast)

// upnpframework / avcontroller api

#include "upnpavrenderingsession.h"     // MUPnPAVRenderingSession

#include "upnpavsessionobserverbase.h" 

// upnpframework / avcontroller helper api

#include "upnpconstantdefs.h"           // KFilterCommon

#include "upnpitemresolver.h"           // MUPnPItemResolver

#include "upnpitemresolverobserver.h"   // MUPnPItemResolverObserver

#include "upnpitemresolverfactory.h"    // UPnPItemResolverFactory

#include "upnpitemutility.h"            // UPnPItemUtility::BelongsToClass

// upnpframework / commonui

#include "upnpcommonui.h"               // common UI for upnp video player dlg

#include "upnprenderingstatemachine.h"  // rendering state machine

// command internal

#include "upnpimagerenderingengineobserver.h"   // the observer interface

#include "upnpimagerenderingengine.h"   // self

#include "upnpperiodic.h"

_LIT( KComponentLogfile, "upnpcommand.log");

#include "upnplog.h"

// CONSTANT DEFINITIONS

const TInt KReactionTimerMicrosec = 100000; // 100 millisec.

// --------------------------------------------------------------------------

// CUpnpImageRenderingEngine::NewL

// --------------------------------------------------------------------------

//

CUpnpImageRenderingEngine* CUpnpImageRenderingEngine::NewL(

            MUPnPAVController& aAVController,

            MUPnPAVRenderingSession& aSession,

            MUpnpImageRenderingEngineObserver& aObserver )

    {

    __LOG( "[UpnpCommand]\t CUpnpImageRenderingEngine::NewL" );

    // Create instance

    CUpnpImageRenderingEngine* self = NULL;

    self = new (ELeave) CUpnpImageRenderingEngine(

            aAVController, aSession, aObserver );

    CleanupStack::PushL( self );

    self->ConstructL( );

    CleanupStack::Pop( self );

    return self;

    }

// --------------------------------------------------------------------------

// CUpnpImageRenderingEngine::CUpnpImageRenderingEngine

// --------------------------------------------------------------------------

//

CUpnpImageRenderingEngine::CUpnpImageRenderingEngine(

            MUPnPAVController& aAVController,

            MUPnPAVRenderingSession& aSession,

            MUpnpImageRenderingEngineObserver& aObserver )

    : iAVController( aAVController )

    , iRenderingSession( aSession )

    , iObserver( aObserver )

    {

    __LOG( "[UpnpCommand]\t CUpnpImageRenderingEngine: Constructor" );

    // Initialise member variables

    iState = EIdle;

    iCurrentResolver = 0;

    iBufferedResolver = 0;

    iRenderingStateMachine = NULL;

    iWlanActive = ETrue;

    // set observer

    iRenderingSession.SetObserver( *this );

    }

// --------------------------------------------------------------------------

// Second phase constructor.

// --------------------------------------------------------------------------

//

void CUpnpImageRenderingEngine::ConstructL()

    {

    __LOG( "[UpnpCommand]\t CUpnpImageRenderingEngine::ConstructL" );

    iTimer = CUPnPPeriodic::NewL( CActive::EPriorityStandard );

    iRenderingStateMachine = 

                  CUpnpRenderingStateMachine::NewL( iRenderingSession );

    iRenderingStateMachine->SetObserver( *this );

    iRenderingStateMachine->SyncL();

    }

// --------------------------------------------------------------------------

// Destructor.

// --------------------------------------------------------------------------

//

CUpnpImageRenderingEngine::~CUpnpImageRenderingEngine()

    {

    __LOG( "[UpnpCommand]\t CUpnpImageRenderingEngine:\

        Destructor" );

    Cleanup();

    // Stop observing the rendering session

    iRenderingSession.RemoveObserver();

    __LOG( "[UpnpCommand]\t CUpnpImageRenderingEngine::\

~CUpnpImageRenderingEngine delete iCurrentResolver" );

    MUPnPItemResolver* tempCurrentResolver = iCurrentResolver;

    iCurrentResolver = NULL;

    delete tempCurrentResolver;

    if ( iRenderingStateMachine )

        {

        iRenderingStateMachine->RemoveObserver();

        delete iRenderingStateMachine;

        iRenderingStateMachine = NULL;

        }

    if( iTimer )

        {    

        iTimer->Cancel();

        delete iTimer;

        iTimer = 0;

        }

    }

// --------------------------------------------------------------------------

// CUpnpImageRenderingEngine::Cleanup

// --------------------------------------------------------------------------

//

void CUpnpImageRenderingEngine::Cleanup()

    {

    __LOG( "[UpnpCommand]\t CUpnpImageRenderingEngine::Cleanup" );

    // reset state

    if ( iState != EShuttingDown )

        {

        iState = EIdle;

        }

    if( iTimer )

        {    

        iTimer->Cancel();

        }

    iBufferingNewImage = EFalse;

    // Delete resolvers

    // Delete for resolvers is done using temporary variables so that we can

    // first nullify the members and then delete the actual objects.

    // This is because local resolver deletion uses active scheduler loops

    // and therefore other asynchronous events may orrur. So we may end

    // up here in Cleanup again, during the resolver is being deleted.

    // if deletion is done the conventional way, the objects get deleted

    // twice, which is not what we want. :-)

    __LOG( "[UpnpCommand]\t CUpnpImageRenderingEngine::\

Cleanup delete iBufferedResolver" );

    MUPnPItemResolver* tempBufferedResolver = iBufferedResolver;

    iBufferedResolver = NULL;

    delete tempBufferedResolver;

    __LOG( "[UpnpCommand]\t CUpnpImageRenderingEngine::Cleanup end" );

    }

// --------------------------------------------------------------------------

// CUpnpImageRenderingEngine::PlayL

// --------------------------------------------------------------------------

//

void CUpnpImageRenderingEngine::PlayL()

    {

    __LOG( "[UpnpCommand]\t CUpnpImageRenderingEngine::PlayL" );

    if ( iState != EShuttingDown )

        {

        if( iTimer->IsActive() )

            {

            __LOG( "[UpnpCommand]\t timer already active" );

            }

        else

            {

            TTimeIntervalMicroSeconds32 delay( KReactionTimerMicrosec );

            iTimer->Start( delay, delay, TCallBack( Timer, this ) );

            }

        }

    else

        {

        __LOG( "[UpnpCommand]\t not doing play in shutting down state" );

        }

    }

// --------------------------------------------------------------------------

// CUpnpImageRenderingEngine::StopL

// --------------------------------------------------------------------------

//

void CUpnpImageRenderingEngine::StopL()

    {

    __LOG( "[UpnpCommand]\t CUpnpImageRenderingEngine::StopL" );

    // cancel any timers that are going on

    iTimer->Cancel();

    // remove buffered images

    iBufferingNewImage = EFalse;

    delete iBufferedResolver;

    iBufferedResolver = 0;

    switch( iState )

        {

        case EIdle:

        case EResolvingItem:

        case EResolveComplete:

            {

            // just cancel the sequence and do nothing

            iState = EIdle;

            break;

            }

        case ERendering: 

            {

            // Send stop action.

            iRenderingStateMachine->CommandL( Upnp::EStop, 0, NULL );

            break;

            }

        case EShuttingDown:

            {

            // command not allowed in this state

            break;

            }

        default:

            {

            __PANIC( __FILE__, __LINE__ );

            break;

            }

        }

    }

// --------------------------------------------------------------------------

// CUpnpImageRenderingEngine::Timer

// timer callback

// --------------------------------------------------------------------------

//

TInt CUpnpImageRenderingEngine::Timer( TAny* aArg )

    {    

    CUpnpImageRenderingEngine* self =

        static_cast<CUpnpImageRenderingEngine*>( aArg );

    TRAPD( error, self->RunTimerL() )

    if ( error != KErrNone )

        {

        self->RunError( error );

        }

    return 0; // do not call again

    }

// --------------------------------------------------------------------------

// CUpnpImageRenderingEngine::RunTimerL

// Timer has triggered, start rendering media.

// --------------------------------------------------------------------------

//

void CUpnpImageRenderingEngine::RunTimerL()

    {

    __LOG1( "[UpnpCommand]\t CUpnpImageRenderingEngine::RunTimerL, state %d",

        iState );

    iTimer->Cancel();

    delete iBufferedResolver;

    iBufferedResolver = iObserver.GetMedia();

    if ( iBufferedResolver == 0 )

        {

        __LOG( "[UpnpCommand]\t resolver returned zero" );

        User::Leave( KErrCancel );

        }

    switch( iState )

        {

        case EIdle: 

            {

            StartResolvingL();

            break;

            }

        case EResolvingItem: // fall through

        case EResolveComplete: // fall through

            {

            // indicate that new image is being buffered. It will be popped

            // from buffer in next callback.

            iBufferingNewImage = ETrue;

            break;

            }

        case ERendering:

            {

            // indicate that new image is being buffered. Send stop signal.

            // new item will be handled after stop completed.

            if( !iBufferingNewImage )

                {

                iBufferingNewImage = ETrue;

                iRenderingStateMachine->CommandL( Upnp::EStop, 0, NULL );

                }

            else

                {

                // stop already sent, wait for response and do nothing

                __LOG( "[UpnpCommand]\t CUpnpImageRenderingEngine::RunTimerL,\

wait for stop" );

                }

            break;

            }

        case EShuttingDown:

            {

            // command not allowed in this state

            break;

            }

        default:

            {

            __PANIC( __FILE__, __LINE__ );

            break;

            }

        }

    }

// --------------------------------------------------------------------------

// CUpnpImageRenderingEngine::RunError

// Exception occurred in the timer body

// --------------------------------------------------------------------------

//

TInt CUpnpImageRenderingEngine::RunError( TInt aError )

    {

    __LOG1( "[UpnpCommand]\t CUpnpImageRenderingEngine::\

RunError aError %d", aError );

    Cleanup();

    SendRenderAck( aError );

    return KErrNone;

    }

// --------------------------------------------------------------------------

// CUpnpImageRenderingEngine::StartResolvingL

// Handles the start up of the item resolving.

// --------------------------------------------------------------------------

//

void CUpnpImageRenderingEngine::StartResolvingL()

    {

    __LOG1( "[UpnpCommand]\t CUpnpImageRenderingEngine::StartResolvingL\

 in state %d",

        iState );

    __ASSERTD( iBufferedResolver, __FILE__, __LINE__ );

    if ( !iBufferedResolver )

        {

        // something is very wrong

        User::Leave( KErrDisconnected );

        }

    // delete old resolver

    // destruction takes time due to unsharing, so set to null first

    // so that this wont be used else where

    MUPnPItemResolver* tempCurrentResolver = iCurrentResolver;

    iCurrentResolver = NULL;

    delete tempCurrentResolver;

    // take queued resolver in use

    iCurrentResolver = iBufferedResolver;

    iBufferedResolver = NULL;

    iBufferingNewImage = EFalse;

    // Update the state

    iState = EResolvingItem;

    // Start resolving the item

    iCurrentResolver->ResolveL( *this );

    }

// --------------------------------------------------------------------------

// CUpnpImageRenderingEngine::ResolveComplete

// Indicates that resolving of an item is complete.

// --------------------------------------------------------------------------

//

void CUpnpImageRenderingEngine::ResolveComplete(

                                    const MUPnPItemResolver& aResolver,

                                    TInt aError )

    {

    __LOG1( "[UpnpCommand]\t CUpnpImageRenderingEngine::ResolveComplete\

 aError %d", aError );

    // if engine is shutting down, no need to check these

    if ( iState == EResolvingItem )

        {

        __ASSERT( &aResolver == iCurrentResolver, __FILE__, __LINE__ );

        if( iBufferingNewImage )

            {

            TRAP( aError, StartResolvingL() );

            }

        else if( aError == KErrNone )

            {

            iState = ERendering;

            const CUpnpItem& item = iCurrentResolver->Item();

            if ( UPnPItemUtility::BelongsToClass( item, KClassImage ) )

                {

                __LOG1( "[UpnpCommand]\t play image item of resolver 0x%d", 

                                                    TInt(iCurrentResolver) );

                Cycle();

                }

            else if ( UPnPItemUtility::BelongsToClass( item, KClassVideo ) )

                {

                __LOG( "[UpnpCommand]\t video, inform observer to play it" );

                aError = iObserver.RenderAck( KErrNotSupported, &item );

                }

            }

        // error handling

        if( aError != KErrNone && iState != EShuttingDown )

            {

            SendRenderAck( aError );

            }

        }

    else if( iState == EShuttingDown )

        {

        // do nothing.

        iState = EIdle;

        }

    else

        {

        __LOG( "[UpnpCommand]\t CUpnpImageRenderingEngine: state error." );

        __PANICD( __FILE__, __LINE__ );

        iState = EIdle;

        }

    }

// --------------------------------------------------------------------------

// CUpnpImageRenderingEngine::SetURIResult

// UPnP AV Controller calls this method as a result for the 'set uri' request.

// --------------------------------------------------------------------------

//

void CUpnpImageRenderingEngine::SetURIResult( TInt aError )

    {    

    __LOG1( "[UpnpCommand]\t CUpnpImageRenderingEngine::SetURIResult\

 in aError %d", aError );

    if ( iState == ERendering )

        {

        if( iBufferingNewImage && aError == KErrNone)

            {

            __LOG( "[UpnpCommand]\t CUpnpImageRenderingEngine::\

SetURIResult - pass cancel to rendering state machine" );

            iRenderingStateMachine->SetURIResult( KErrCancel );

            }

        else if( aError == KErrNone )

            {

            __LOG( "[UpnpCommand]\t CUpnpImageRenderingEngine::\

SetURIResult - pass uri result to rendering state machine" );

            iRenderingStateMachine->SetURIResult( aError );

            }

        }

    else if ( iState == EShuttingDown )

        {

        // do nothing

        }

    }

// --------------------------------------------------------------------------

// CUpnpImageRenderingEngine::InteractOperationComplete

// Called by UpnpAvController to indicate that play is complete.

// --------------------------------------------------------------------------

//

void CUpnpImageRenderingEngine::InteractOperationComplete(

    TInt aError,

    TUPnPAVInteractOperation aOperation )

    {

    __LOG2( "[UpnpCommand]\t CUpnpImageRenderingEngine::\

InteractOperationComplete aOperation %d aError %d", aOperation, aError );

    if ( iState != EShuttingDown )

        {

        __LOG( "[UpnpCommand]\t CUpnpImageRenderingEngine::\

InteractOperationComplete - pass operation to rendering state machine" );

        iRenderingStateMachine->InteractOperationComplete( 

            aError, aOperation );

        }

    }

// --------------------------------------------------------------------------