/*

* Copyright (c) 2006-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:      implements a renderer playback state machine

*

*/

// INCLUDE FILES

// System

#include <in_sock.h>

#include <mmf/common/mmfcontrollerpluginresolver.h>

// upnp stack api

#include <upnpdevice.h>

#include <upnpservice.h>

#include <upnpstring.h>

// dlnasrv / mediaserver api

#include <upnpcontainer.h>

#include <upnpitem.h>

#include <upnpelement.h>

#include <upnpdlnaprotocolinfo.h>

// dlnasrv / xmlparser api

#include "upnpxmlparser.h"

// dlnasrv / avcontroller api

#include "upnpavcontrollerglobals.h"

// dlnasrv / avcontroller helper api

#include "upnpitemutility.h"

#include "upnpconstantdefs.h" // for upnp-specific stuff

// dlnasrv / internal api

#include "upnpmetadatafetcher.h"

#include "upnpcommonutils.h"

#include "upnpcdsreselementutility.h"

#include "upnpxmleventparser.h"

// dlnasrv / avcontroller internal

#include "upnpavcontrollerserver.h"

#include "upnpavrequest.h"

#include "upnpavdispatcher.h"

#include "upnpaverrorhandler.h"

#include "upnpavdeviceextended.h"

#include "upnpdevicerepository.h"

#include "upnpplaybacksession.h"

#include "upnpavcontrolpoint.h"

#include "upnpavcpstrings.h"

using namespace UpnpAVCPStrings;

_LIT( KComponentLogfile, "upnpavcontrollerserver.txt");

#include "upnplog.h"

_LIT8( KNormalSpeed,        "1" );

_LIT8( KMasterVolume,       "Master" );

_LIT8( KMuteOn,             "1" );

_LIT8( KMuteOff,            "0" );

_LIT8( KAsterisk,           "*" );

_LIT8( KConnectioMgr,       "urn:upnp-org:serviceId:ConnectionManager" );

_LIT8( KInput,              "Input" );

_LIT8( KDefaultPeerConnectionID, "-1" );

const TInt KDefaultInstanceId   = 0;

const TInt KMaxVolume           = 100;

const TInt KMaxIntLength        = 10;

_LIT8( KNoMedia, "NO_MEDIA_PRESENT" );

_LIT8( KPlaying, "PLAYING" );

_LIT8( KPausedPlayback, "PAUSED_PLAYBACK" );

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

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

// CUPnPPlaybackSession::NewL

// See upnpplaybacksession.h

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

CUPnPPlaybackSession* CUPnPPlaybackSession::NewL

    (

    CUpnpAVControllerServer& aServer,

    TInt aSessionId,

    const TDesC8& aUuid

    )

    {

    CUPnPPlaybackSession* self = new (ELeave) CUPnPPlaybackSession(

        aServer, aSessionId );

    CleanupStack::PushL( self );

    self->ConstructL( aUuid );

    CleanupStack::Pop( self );

    return self;

    }

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

// CUPnPPlaybackSession::CUPnPPlaybackSession

// See upnpplaybacksession.h

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

CUPnPPlaybackSession::CUPnPPlaybackSession

    (

    CUpnpAVControllerServer& aServer,

    TInt aSessionId

    ):

    iServer( aServer ),

    iSessionId( aSessionId ),

    iAVTInstanceId( KDefaultInstanceId ),

    iRCInstanceId( KDefaultInstanceId ),

    iConnectionId( KErrNotFound ),

    iIPSessionIdCommand( KErrNotFound ),

    iIPSessionIdSetting( KErrNotFound ),

    iEventingActive( EFalse ),

    iPlaybackState( EUninitialized ),

    iMuteState( EUnknown ),

    iVolume( KErrNotFound ),

    iInitialEventReceived(EFalse),

    iPreviousTransportState( CUPnPAVTEvent::ENoMediaPresent )

    {

    }

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

// CUPnPPlaybackSession::~CUPnPPlaybackSession

// See upnpplaybacksession.h

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

CUPnPPlaybackSession::~CUPnPPlaybackSession()

    {

    __LOG( "CUPnPPlaybackSession::~CUPnPPlaybackSession" );

    if( ( iPlaybackState == EPlaying || iPlaybackState == EPaused ) && 

         !iInitialEventReceived )

        {

        if( iDevice && iServer.DeviceRepository().IsWlanActive() )

            {

            __LOG( "~CUPnPPlaybackSession - \

playback still ongoing, send stop" );    

            TRAP_IGNORE( EmergencyStopL() );

            }

        else

            {

            __LOG( "~CUPnPPlaybackSession - \

playback still ongoing, wlan not active" );    

            }    

        }

    delete iEventMessage;

    delete iSettingMessage;

    delete iCommandMessage;

    delete iDeviceMessage;

    delete iInitialEventMsg;

    delete iLocalMediaServerUuid;

    delete iEventParser;

    iEventQue.Reset();

    iEventQue.Close();

    if( iEventingActive && iDevice )

        {

        __LOG( "~CUPnPPlaybackSession - UnSubscribeDeviceL" );

        TRAP_IGNORE( iServer.DeviceRepository().UnSubscribeDeviceL(

            iDevice->Uuid() ) );

        iServer.Dispatcher().UnRegisterEvents( *this );

        iEventingActive = EFalse;            

        }

    delete iDevice;        

    delete iPInfoForPrevious;

    delete iCurrentUri;

    delete iCurrentItem;

    if( iTimer )

        {

        iTimer->Cancel();

        delete iTimer;

        }

	delete iUuid;

    }

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

// CUPnPPlaybackSession::ConstructL

// See upnpplaybacksession.h

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

void CUPnPPlaybackSession::ConstructL( const TDesC8& aUuid )

    {

    __LOG( "CUPnPPlaybackSession::ConstructL" );

    iEventParser = CUPnPXMLEventParser::NewL();

    const RPointerArray<CUpnpAVDeviceExtended>& devList =

        iServer.DeviceRepository().DeviceList();

    TInt count = devList.Count();

    TInt i;

    for( i = 0; i < count; i++ )

        {

        if( devList[ i ]->Local() )

            {

            __LOG( "CUPnPPlaybackSession::ConstructL - Local MS found!" );

            __ASSERT( !iLocalMediaServerUuid, __FILE__, __LINE__ );

            iLocalMediaServerUuid = devList[i]->Uuid().AllocL();

            }

        if( devList[ i ]->Uuid() == aUuid )

            {

            __ASSERT( !iDevice, __FILE__, __LINE__ );

            iDevice = CUpnpAVDeviceExtended::NewL( *devList[ i ] );

            }

        }        

    if( !iDevice )

        {

        User::Leave( KErrNotFound );

        }

    iUuid = HBufC8::NewL( aUuid.Length() );

    TPtr8 uuidPtr( iUuid->Des() );

    uuidPtr.Copy( aUuid );

    iTimer = CUPnPAVTimer::NewL( *this, CUPnPAVTimer::ETimerFailSafe );

    }

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

// CUPnPPlaybackSession::CpDeviceL

// See upnpplaybacksession.h

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

const CUpnpDevice* CUPnPPlaybackSession::CpDeviceL()

    {

    const CUpnpDevice* device = iServer.ControlPoint().Device( iUuid->Des() );

    if( !device )

        {

		// Control point resets device information once renderer or wlan 

		// connection lost. Avoid panicing by leaving.

        __LOG( "CUPnPPlaybackSession::CpDeviceL - no device, leaving" );

        User::Leave( KErrNotReady );

        }

    return device;

    }

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

// CUPnPPlaybackSession::ActionResponseL

// See upnpplaybacksession.h

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

void CUPnPPlaybackSession::ActionResponseL( CUpnpAction* aAction )

    {

    if ( aAction->Name().Compare( KSetVolume ) == 0 )

        {

        RcSetVolumeResponse(

            aAction->Error(),

            aAction->ArgumentValue( KDesiredVolume ) );

        }

    else if ( aAction->Name().Compare( KGetVolume ) == 0 )

        {

        RcVolumeResponse( 

            aAction->Error(),

            aAction->ArgumentValue( KCurrentVolume ) );

        }

    else if ( aAction->Name().Compare( KSetMute ) == 0 )

        {

        RcSetMuteResponse( 

            aAction->Error(),

            aAction->ArgumentValue( KDesiredMute ) );

        }

    else if ( aAction->Name().Compare( KGetMute ) == 0 )

        {

        RcMuteResponse( 

             aAction->Error(),

             aAction->ArgumentValue( KCurrentMute ) );

        }

    else if ( aAction->Name().Compare( KSetAVTransportURI ) == 0 )

        {

        AvtSetTransportUriResponse(

            aAction->Error() );

        }

    else if ( aAction->Name().Compare( KGetMediaInfo ) == 0 )

        {

        AvtGetMediaInfoResponse(

            aAction->Error(),

            aAction->ArgumentValue( KCurrentURI ) );

        }

    else if ( aAction->Name().Compare( KGetTransportInfo ) == 0 )

        {

        AvtGetTransportInfoResponse(

            aAction->Error(),

            aAction->ArgumentValue( KCurrentTransportState ) );

        }

    else if ( aAction->Name().Compare( KGetPositionInfo ) == 0 )

        {

        AvtPositionInfoResponse(

            aAction->Error(),

            aAction->ArgumentValue( KTrackDuration ),

            aAction->ArgumentValue( KRelTime ) );

        }

    else if ( aAction->Name().Compare( KStop ) == 0 )

        {				

        AvtStopResponse(

            aAction->Error() );

        }

    else if ( aAction->Name().Compare( KPlay ) == 0 )

        {				

        AvtPlayResponse(

            aAction->Error() );

        }

    else if ( aAction->Name().Compare( KPause ) == 0 )

        {		

        AvtPauseResponse(

            aAction->Error() );

        }

    else if ( aAction->Name().Compare( KSeek ) == 0 )

        {	

        AvtSeekResponse(

            aAction->Error() );

        }

    else if (aAction->Name().Compare( KPrepareForConnection ) == 0)

        {

        TLex8 connectionLex1( aAction->ArgumentValue( KConnectionId ) );

        TInt connectionId;

        User::LeaveIfError( connectionLex1.Val( connectionId ) );

        TLex8 transportLex1( aAction->ArgumentValue( KAVTransportId ) );

        TInt transportId;

        User::LeaveIfError( transportLex1.Val( transportId ) );

        TLex8 rscLex3( aAction->ArgumentValue( KRcsID ) );

        TInt rscId;

        User::LeaveIfError( rscLex3.Val( rscId ) );

        CmPrepareResponse(

            aAction->Error(),

            connectionId,

            transportId,

            rscId );

        }

    }

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

// CUPnPPlaybackSession::StateUpdatedL

// See upnpplaybacksession.h

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

void CUPnPPlaybackSession::StateUpdatedL(CUpnpService* aService)

    {

    if (aService->ServiceType().Match( KRenderingControl ) != KErrNotFound )

        {

        CUpnpStateVariable* lastChange = aService->StateVariable( KLastChange );

        if( lastChange ) 

            {

            RcLastChangeEvent(

                lastChange->Value() );

            }

        }

    else if (aService->ServiceType().Match( KAVTransport ) != KErrNotFound )

        {

        CUpnpStateVariable* lastChange = aService->StateVariable( KLastChange );

        if( lastChange )

            {

            AvtLastChangeEvent(

                lastChange->Value() );

            }

        }

    }

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

// CUPnPPlaybackSession::HttpResponseL

// See upnpplaybacksession.h

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

void CUPnPPlaybackSession::HttpResponseL( CUpnpHttpMessage* /*aMessage*/ )

    {

    // No implementation required

    }

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

// CUPnPPlaybackSession::DeviceDiscoveredL

// See upnpplaybacksession.h

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

void CUPnPPlaybackSession::DeviceDiscoveredL( CUpnpDevice* /*aDevice*/ )

    {

    // No implementation required

    }

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

// CUPnPPlaybackSession::DeviceDisappearedL

// See upnpplaybacksession.h

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

void CUPnPPlaybackSession::DeviceDisappearedL( CUpnpDevice* /*aDevice*/ )    {

    // No implementation required

    }

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

// CUPnPPlaybackSession::RcSetVolumeResponse

// See upnpplaybacksession.h

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

void CUPnPPlaybackSession::RcSetVolumeResponse(

    TInt aErr, 

    const TDesC8& aDesiredVolume )

    {

    __LOG1( "CUPnPPlaybackSession::RcSetVolumeResponse: %d", aErr );

    iServer.Dispatcher().UnRegister( iIPSessionIdSetting );

    iIPSessionIdSetting = KErrNotFound;

    if( iSettingMessage )

        {

        aErr = UPnPAVErrorHandler::ConvertToSymbianErrorCode( aErr,

            EUPnPRenderingControlError );    

        if( aErr == KErrNone )

            {

            TInt vol;

            TLex8 lex( aDesiredVolume );

            TInt err = lex.Val( vol );

            if(  err == KErrNone )

                {

                TInt maxVolume = iDevice->MaxVolume();

                // If max volume not KMaxVolume

                if( maxVolume != KMaxVolume )

                    {

                    // Convert volume to match max volume 100

                    TReal tempVolumeLevel = vol;

                    TReal tempMaxVolume = maxVolume;

                    vol = KMaxVolume * tempVolumeLevel / tempMaxVolume;

                    }

                iVolume = vol;

                TPckg<TInt> resp2( vol );

                iSettingMessage->Write( 2, resp2 );

                iSettingMessage->Complete( EAVControllerSetVolumeCompleted );

                delete iSettingMessage; iSettingMessage = NULL;       

                }

            else

                {

                iSettingMessage->Complete( err );

                delete iSettingMessage; iSettingMessage = NULL;

                }    

            }

        else

            {

            iSettingMessage->Complete( aErr );

            delete iSettingMessage; iSettingMessage = NULL;

            }                   

        }

    else

        {

        __LOG( "RcSetVolumeResponse - no msg" );

        }    

    }

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

// CUPnPPlaybackSession::RcVolumeResponse

// See upnpplaybacksession.h

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

void CUPnPPlaybackSession::RcVolumeResponse(

    TInt aErr, 

    const TDesC8& aCurrentVolume)

    {

    __LOG1( "CUPnPPlaybackSession::RcVolumeResponse: %d", aErr );    

    iServer.Dispatcher().UnRegister( iIPSessionIdSetting );

    iIPSessionIdSetting = KErrNotFound;

    if( iSettingMessage )

        {

        aErr = UPnPAVErrorHandler::ConvertToSymbianErrorCode( aErr,

            EUPnPRenderingControlError );

        if( aErr == KErrNone )

            {

            TInt vol;

            TLex8 lex( aCurrentVolume );

            TInt err = lex.Val( vol );

            if(  err == KErrNone )

                {

               // Get device's maximum volume value

                TInt maxVolume = iDevice->MaxVolume();

                // If max volume not KMaxVolume

                if( maxVolume != KMaxVolume )

                    {

                    // Convert volume to match max volume KMaxVolume

                    TReal tempVolumeLevel = vol;

                    TReal tempMaxVolume = maxVolume;

                    vol = KMaxVolume * tempVolumeLevel / tempMaxVolume;

                    }            

                iVolume = vol;

                TPckg<TInt> resp1( vol );

                iSettingMessage->Write( 1, resp1 );

                iSettingMessage->Complete( EAVControllerGetVolumeCompleted );

                delete iSettingMessage; iSettingMessage = NULL;