/*

* Copyright (c) 2007,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:  Implementation of generic upnp remote rendering state machine

*

*/

// INCLUDES

// dlnasrv / mediaserver api

#include <upnpitem.h>

// dlnasrv / avcontroller api

#include "upnpavrenderingsession.h"

#include "upnpavdevice.h"

#include "upnpitemutility.h"

#include "upnpconstantdefs.h"

#include "upnprenderingstatemachineconstants.h"

#include "upnprenderingstatemachineobserver.h"

// dlnasrv / component internal

#include "upnprenderingoperation.h"

#include "upnprenderingplaytimecalculator.h"

#include "upnpretraces.h"

#include "upnprenderingstatemachine.h"

#include "upnpavcontrollerglobals.h"

_LIT( KComponentLogfile, "upnprenderingstatemachine.txt");

#include "upnplog.h"

// CONSTANTS

const TInt64 KMicrosecondsInMillisecond = 1000;

const TInt KSeekThresholdTime = 2000; //ms

// ======== MEMBER FUNCTIONS ========

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

// CUpnpRenderingStateMachine::NewL

// Static constructor.

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

//

EXPORT_C CUpnpRenderingStateMachine* CUpnpRenderingStateMachine::NewL( 

    MUPnPAVRenderingSession& aSession )

    {

    CUpnpRenderingStateMachine* self =

        new (ELeave) CUpnpRenderingStateMachine( aSession );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CUpnpRenderingStateMachine::CUpnpRenderingStateMachine

// default constructor

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

//

CUpnpRenderingStateMachine::CUpnpRenderingStateMachine( 

    MUPnPAVRenderingSession& aSession )

    : iSession( aSession )

    {

    iState = Upnp::EOffSync;

    iObserver = NULL;

    iOptions = 0;

    iSelector = 0;

    }

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

// CUpnpRenderingStateMachine::ConstructL

// 2nd phase constructor

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

//

void CUpnpRenderingStateMachine::ConstructL()

    {

    __LOG( "RenderingStateMachine::ConstructL" );

    iPlaytimeCalculator = new(ELeave) CUpnpRenderingPlaytimeCalculator();

    }

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

// CUpnpRenderingStateMachine::~CUpnpRenderingStateMachine

// destructor

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

//

EXPORT_C CUpnpRenderingStateMachine::~CUpnpRenderingStateMachine()

    {

    __LOG( "RenderingStateMachine: ~CUpnpRenderingStateMachine" );

    delete iPlaytimeCalculator;

    iQueue.Close();

    iObserver = NULL;

    __LOG( "RenderingStateMachine: ~CUpnpRenderingStateMachine end" );

    }

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

// CUpnpRenderingStateMachine::SetOptions

// sets the option flags for this state machine

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

//

EXPORT_C void CUpnpRenderingStateMachine::SetOptions( TInt aOptions )

    {

    iOptions = aOptions;

    }

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

// CUpnpRenderingStateMachine::Options

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

//

EXPORT_C TInt CUpnpRenderingStateMachine::Options() const

    {

    return iOptions;

    }

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

// CUpnpRenderingStateMachine::SetObserver

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

//

EXPORT_C void CUpnpRenderingStateMachine::SetObserver(

    MUpnpRenderingStateMachineObserver& aObserver )

    {

    iObserver = &aObserver;

    }

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

// CUpnpRenderingStateMachine::RemoveObserver

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

//

EXPORT_C void CUpnpRenderingStateMachine::RemoveObserver()

    {

    iObserver = NULL;

    }

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

// CUpnpRenderingStateMachine::SetResourceSelector

// custom selection for resource inside item

// selects which resource is used in SetAvTransportUri

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

//

EXPORT_C void CUpnpRenderingStateMachine::SetResourceSelector(

    MUPnPResourceSelector& aSelector )

    {

    __LOG( "RenderingStateMachine: SetResourceSelector" );

    iSelector = &aSelector;

    }

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

// CUpnpRenderingStateMachine::SyncL

// synchronises the state machine with renderer

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

//

EXPORT_C void CUpnpRenderingStateMachine::SyncL()

    {

    __LOG( "CUpnpRenderingStateMachine::SyncL" );

    __ASSERT( !IsInSync(), __FILE__, __LINE__ );

    __ASSERT( !IsBusy(), __FILE__, __LINE__ );

    if ( IsInSync() )

        {

        User::Leave( KErrGeneral );

        }

    if ( IsBusy() )

        {

        User::Leave( KErrServerBusy );

        }

    TUpnpRenderingOperation sync(

        Upnp::ESync );

    PushAndExecuteL( sync );

    }

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

// CUpnpRenderingStateMachine::SetOffSync

// sets this state machine off sync

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

//

EXPORT_C void CUpnpRenderingStateMachine::SetOffSync()

    {

    __LOG( "CUpnpRenderingStateMachine::SetOffSync" );

    __ASSERT( !IsBusy(), __FILE__, __LINE__ );

    iState = Upnp::EOffSync;

    }

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

// CUpnpRenderingStateMachine::IsInSync

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

//

EXPORT_C TBool CUpnpRenderingStateMachine::IsInSync() const

    {

    return (iState & Upnp::EStateMaskInSync) != 0;

    }

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

// CUpnpRenderingStateMachine::Command

// Issues a command to the renderer through the state machine

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

//

EXPORT_C void CUpnpRenderingStateMachine::CommandL(

    Upnp::TCommand aCommand,

    TInt aCommandParameter,

    const CUpnpItem* aMedia )

    {

    __LOG1( "CUpnpRenderingStateMachine::CommandL cmd = %d",aCommand );

    TUpnpRenderingOperation cmd(

        aCommand, aCommandParameter, aMedia );

    PushAndExecuteL( cmd );

    }

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

// CUpnpRenderingStateMachine::IsBusy

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

//

EXPORT_C TBool CUpnpRenderingStateMachine::IsBusy() const

    {

    return !IsFree();

    }

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

// CUpnpRenderingStateMachine::State

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

//

EXPORT_C Upnp::TState CUpnpRenderingStateMachine::State() const

    {

    return iState;

    }

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

// CUpnpRenderingStateMachine::Duration

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

//

EXPORT_C TInt CUpnpRenderingStateMachine::Duration() const

    {

    __LOG( "CUpnpRenderingStateMachine::Duration" );

    __ASSERT( iState & Upnp::EStateMaskActive,

        __FILE__, __LINE__ );

    __ASSERT( iPlaytimeCalculator, __FILE__, __LINE__ );

    return iPlaytimeCalculator->Duration();

    }

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

// CUpnpRenderingStateMachine::Position

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

//

EXPORT_C TInt CUpnpRenderingStateMachine::Position() const

    {

    __LOG( "CUpnpRenderingStateMachine::Position" );

    __ASSERT( iState & Upnp::EStateMaskActive,

        __FILE__, __LINE__ );

    __ASSERT( iPlaytimeCalculator, __FILE__, __LINE__ );

    return iPlaytimeCalculator->Position();

    }

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

// CUpnpRenderingStateMachine::HasPauseCapability

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

//

EXPORT_C TBool CUpnpRenderingStateMachine::HasPauseCapability() const

    {

    return iSession.Device().PauseCapability();

    }

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

// CUpnpRenderingStateMachine::InteractOperationComplete

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

//

EXPORT_C void CUpnpRenderingStateMachine::InteractOperationComplete(

    TInt aError, TUPnPAVInteractOperation aOperation )

    {

    __LOG( "CUpnpRenderingStateMachine::InteractOperationComplete" );

    Process(

        CUpnpRenderingStateMachine::EInteractOperationComplete,

        aError, &aOperation );

    }

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

// CUpnpRenderingStateMachine::PositionInfoResult

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

//

EXPORT_C void CUpnpRenderingStateMachine::PositionInfoResult( 

    TInt aError, const TDesC8& aPosition, const TDesC8& aLength )

    {

    __LOG( "CUpnpRenderingStateMachine::PositionInfoResult" );

    Process(

        CUpnpRenderingStateMachine::EPositionInfo,

        aError, (TAny*)&aPosition, (TAny*)&aLength );

    }

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

// CUpnpRenderingStateMachine::SetURIResult

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

//

EXPORT_C void CUpnpRenderingStateMachine::SetURIResult( TInt aError )

    {

    __LOG( "CUpnpRenderingStateMachine::SetURIResult" );

    Process(

        CUpnpRenderingStateMachine::ESetUriResult,

        aError );

    }

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

// CUpnpRenderingStateMachine::SetNextURIResult

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

//

EXPORT_C void CUpnpRenderingStateMachine::SetNextURIResult( TInt /*aError*/ )

    {

    __LOG( "CUpnpRenderingStateMachine::SetNextURIResult" );

    __PANIC( __FILE__, __LINE__ );

    }

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

// CUpnpRenderingStateMachine::ReportSyncReady

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

//

void CUpnpRenderingStateMachine::ReportSyncReady(

    TInt aError, Upnp::TState aNewState )

    {

    __LOG3( "RenderingStateMachine: SyncReady err=%i %s->%s",

        aError, StateName( iState ), StateName( aNewState ) );

    iState = aNewState;

    if ( iObserver )

        {

        iObserver->RendererSyncReady( aError, iState );

        }

    }

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

// CUpnpRenderingStateMachine::ReportStateChanged

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

//

void CUpnpRenderingStateMachine::ReportStateChanged(

    TInt aError, Upnp::TState aNewState,

    TBool aActionResponse, TInt aStateParam )

    {

    __LOG3( "RenderingStateMachine: StateChanged err=%i %s->%s",

        aError, StateName( iState ), StateName( aNewState ) );

    iState = aNewState;

    if ( iObserver )

        {

        iObserver->RenderingStateChanged(

            aError, iState, aActionResponse, aStateParam );

        }

    }

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

// CUpnpRenderingStateMachine::ReportPositionSync

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

//

void CUpnpRenderingStateMachine::ReportPositionSync( TInt aError,

    Upnp::TPositionMode aMode,

    TInt aDuration, TInt aPosition )

    {

    __LOG1( "RenderingStateMachine: PositionSync %i", aError );

    if ( iObserver )

        {

        iObserver->PositionSync( aError, aMode, aDuration, aPosition );

        }

    }

/*****************************************

 ** State machine states implementation ** 

 *****************************************/

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

// CUpnpRenderingStateMachine::ExecuteOperationL

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

//

MUpnpRenderingOperationExecutor::TResult 

CUpnpRenderingStateMachine::ExecuteOperationL(

    const TUpnpRenderingOperation& aOperation,

    const TUpnpRenderingOperation& aCurrent )

    {

    __LOG1( "RenderingStateMachine: ExecuteOperationL (operation=%d)",

        aOperation.Command() );

    MUpnpRenderingOperationExecutor::TResult ret(ECompleted);

    switch( aOperation.Command() )

        {

        case Upnp::ESync:

            {

            ret = ExecuteOperationSyncL( aOperation, aCurrent );

            break;

            }

        case Upnp::EPlay:

            {

            ret = ExecuteOperationPlayL( aOperation, aCurrent );

            break;

            }

        case Upnp::EStop:

            {

            ret = ExecuteOperationStopL( aOperation, aCurrent );

            break;

            }

        case Upnp::EPause:

            {

            ret = ExecuteOperationPauseL( aOperation, aCurrent );

            break;

            }

        case Upnp::EResume:

            {

            ret = ExecuteOperationResumeL( aOperation, aCurrent );

            break;

            }

        case Upnp::ERestart:

            {

            ret = ExecuteOperationRestartL( aOperation, aCurrent );

            break;

            }

        case Upnp::ESeek:

            {

            ret = ExecuteOperationSeekL( aOperation, aCurrent );

            break;

            }

        case Upnp::ECalibrate:

            {

            ret = ExecuteOperationCalibrateL( aOperation, aCurrent );

            break;

            }

        case Upnp::ESetUri:

            {

            ret = ExecuteOperationSetUriL( aOperation, aCurrent );

            break;

            }

        default:

            __PANIC( __FILE__, __LINE__ );

        }

    return ret;

    }

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

// CUpnpRenderingStateMachine::ProcessOperationL

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

//

MUpnpRenderingOperationExecutor::TResult 

CUpnpRenderingStateMachine::ProcessOperationL(

    const TUpnpRenderingOperation& aOperation, TInt aEvent,

    TInt aError, const TAny* aParam1, const TAny* aParam2 )

    {

    __LOG2( "RenderingStateMachine: ProcessOperationL (event=%d) (aError=%d)",

            aEvent, aError );

    MUpnpRenderingOperationExecutor::TResult ret(ECompleted);

    switch( aEvent )

        {

        case EInteractOperationComplete:

            {

            TUPnPAVInteractOperation op =

                *(TUPnPAVInteractOperation*)aParam1;

            if ( op == EUPnPAVPlay 

              || op == EUPnPAVPlayUser 

              || op == EUPnPAVStop 

              || op == EUPnPAVStopUser 

              || op == EUPnPAVPause 

              || op == EUPnPAVPauseUser

              || op == EUPnPAVSeek )

                {

                ret = ProcessAVEvents( aOperation, op, aError );

                }

            else if ( op == EUPnPAVTransition )

                {

                ret = EContinue;

                __LOG1( "RenderingStateMachine: Transition %d", aError );

                }

            else

                {

                __PANIC( __FILE__, __LINE__ );

                }

            break;

            }

        case EPositionInfo: 

            {

            const TDesC8& pos = *(const TDesC8*)aParam1;

            const TDesC8& len = *(const TDesC8*)aParam2;

            ret = ProcessPositionInfo( aOperation, aError, pos, len );

            break;

            }

        case ESetUriResult:

            {

            ret = ProcessSetURIResultL( aOperation, aError );

            break;

            }

        default:

            {

            __PANIC( __FILE__, __LINE__ );

            }

        }

    return ret;

    }

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

// CUpnpRenderingStateMachine::HandleAsyncError

// cancels the ongoing operation

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

//

void CUpnpRenderingStateMachine::HandleAsyncError(

    const TUpnpRenderingOperation& aOperation, TInt aError )

    {

    __LOG( "RenderingStateMachine: HandleAsyncError" );

    switch ( aOperation.Command() )

        {

        case Upnp::ESync:

            {

            ReportSyncReady( aError, State() );

            break;

            }

        case Upnp::EPlay:

            {

            if ( aOperation.IsUserOriented() )

                {

                ReportStateChanged( aError, 

                    Upnp::EStopped, ETrue );

                }

            break;

            }

        case Upnp::EStop:

            {

            if ( aOperation.IsUserOriented() )

                {

                ReportStateChanged( aError, State(), ETrue );

                }

            break;

            }