/*

* Copyright (c) 2006 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 <upnpcontainer.h>

#include <upnpservice.h>

#include <upnpitem.h>

#include <upnpelement.h>

#include <upnpstring.h>

#include <upnpmediaserverclient.h>

#include <upnpdlnaprotocolinfo.h>

#include <upnpavcontrolpoint.h>

// upnpframework / xmlparser api

#include "upnpxmlparser.h"

// upnpframework / avcontroller api

#include "upnpavcontrollerglobals.h"

// upnpframework / avcontroller helper api

#include "upnpitemutility.h"

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

// upnpframework / internal api's

#include "upnpmetadatafetcher.h"

#include "upnpcommonutils.h"

#include "upnpcdsreselementutility.h"

#include "upnpxmleventparser.h"

// avcontroller internal

#include "upnpavcontrollerserver.h"

#include "upnpavrequest.h"

#include "upnpfilesharingactive.h"

#include "upnpavdispatcher.h"

#include "upnpaverrorhandler.h"

#include "upnpavdeviceextended.h"

#include "upnpdevicerepository.h"

#include "upnpplaybacksession.h"

#include "upnpperiodic.h"

_LIT( KComponentLogfile, "upnpavcontrollerserver.txt");

#include "upnplog.h"

_LIT8( KPlaying,            "PLAYING" );

_LIT8( KPaused,             "PAUSED_PLAYBACK" );

_LIT8( KStopped,            "STOPPED" );

_LIT8( KNormalSpeed,        "1" );

_LIT8( KMasterVolume,       "Master" );

_LIT8( KMuteOn,             "1" );

_LIT8( KMuteOff,            "0" );

_LIT8( KAsterisk,           "*" );

const TInt KDefaultInstanceId   = 0;

const TInt KExpectedCount       = 1;

const TInt KMaxVolume           = 100;

// Timer to wait until sending the play action after set transport uri.

// For some reason, some equipments can not responce play action 

// immediately after set transport uri, eg. Kiss 1600.  

const TInt KPlayDelayTimerInterval = 1000000;

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

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

// CUPnPPlaybackSession::NewL

// See upnpplaybacksession.h

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

CUPnPPlaybackSession* CUPnPPlaybackSession::NewL

    (

    RUpnpMediaServerClient& aClient,

    CUpnpAVControllerServer& aServer,

    TInt aSessionId,

    const TDesC8& aUuid

    )

    {

    CUPnPPlaybackSession* self = new (ELeave) CUPnPPlaybackSession(

        aClient, aServer, aSessionId );

    CleanupStack::PushL( self );

    self->ConstructL( aUuid );

    CleanupStack::Pop( self );

    return self;

    }

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

// CUPnPPlaybackSession::CUPnPPlaybackSession

// See upnpplaybacksession.h

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

CUPnPPlaybackSession::CUPnPPlaybackSession

    (

    RUpnpMediaServerClient& aClient,

    CUpnpAVControllerServer& aServer,

    TInt aSessionId

    ):

    iServer( aServer ),

    iMediaServer( aClient ),

    iSessionId( aSessionId ),

    iInstanceId( KDefaultInstanceId ),

    iIPSessionIdCommand( KErrNotFound ),

    iIPSessionIdSetting( KErrNotFound ),

    iEventingActive( EFalse ),

    iMuteState( EUnknown ),

    iVolume( -1 )

    {

    }

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

// CUPnPPlaybackSession::~CUPnPPlaybackSession

// See upnpplaybacksession.h

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

CUPnPPlaybackSession::~CUPnPPlaybackSession()

    {

    __LOG( "CUPnPPlaybackSession::~CUPnPPlaybackSession" );

    if( iPlaybackState == EPlaying || iPlaybackState == EPaused ||

        iPlaybackState == EPlaySent )

        {

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

            {

            __LOG( "~CUPnPPlaybackSession - \

playback still ongoing, send stop" );    

            TRAP_IGNORE( iServer.ControlPoint().AvtStopActionL( 

                iDevice->Uuid(), iInstanceId ) );            

            }

        else

            {

            __LOG( "~CUPnPPlaybackSession - \

playback still ongoing, wlan not active" );    

            }    

        }

    if( iSharedItem && iItemShared && iFileSharing )

        {

        TRAP_IGNORE( iFileSharing->UnShareItemL( iSharedItem->Id() ) );

        }

    if( iNextSharedItem && iNextItemShared && iFileSharing )

        {

        TRAP_IGNORE( iFileSharing->UnShareItemL( iNextSharedItem->Id() ) );

        }

    delete iFileSharing;

    //iMediaServer.Close();

    delete iSharedItem;

    delete iNextSharedItem;

    delete iEventMessage;

    delete iSettingMessage;

    delete iCommandMessage;

    delete iDeviceMessage;

    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 the playdelay timer

    if( iPlayDelayTimer )

        {

        iPlayDelayTimer->Cancel();

        delete iPlayDelayTimer;

        }

    }

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

// CUPnPPlaybackSession::ConstructL

// See upnpplaybacksession.h

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

void CUPnPPlaybackSession::ConstructL( const TDesC8& aUuid )

    {

    __LOG( "CUPnPPlaybackSession::ConstructL" );

    iFileSharing = CUPnPFileSharingActive::NewL();

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

            __ASSERTD( !iLocalMediaServerUuid, __FILE__, __LINE__ );

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

            }

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

            {

            __ASSERTD( !iDevice, __FILE__, __LINE__ );

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

            }

        }        

    if( !iDevice )

        {

        User::Leave( KErrNotFound );

        }

    // create the playdelaytimer

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

    }

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

// CUPnPPlaybackSession::RcSetVolumeResponse

// See upnpplaybacksession.h

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

void CUPnPPlaybackSession::RcSetVolumeResponse(

    const TDesC8& /*aUuid*/,

    TInt aSessionId,

    TInt aErr, 

    const TDesC8& /*aInstance*/, 

    const TDesC8& /*aChannel*/, 

    const TDesC8& aDesiredVolume )

    {

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

    __ASSERTD( iIPSessionIdSetting == aSessionId, __FILE__, __LINE__ );

    iServer.Dispatcher().UnRegister( iIPSessionIdSetting );

    //iSettingPending = EFalse;

    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(

    const TDesC8& /*aUuid*/,

    TInt aSessionId,

    TInt aErr, 

    const TDesC8& /*aInstance*/, 

    const TDesC8& /*aChannel*/, 

    const TDesC8& aCurrentVolume)

    {

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

    __ASSERTD( iIPSessionIdSetting == aSessionId, __FILE__, __LINE__ );

    iServer.Dispatcher().UnRegister( iIPSessionIdSetting );

    //iSettingPending = EFalse;

    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;      

                }

            else

                {

                iSettingMessage->Complete( err );

                delete iSettingMessage; iSettingMessage = NULL;      

                }    

            }

        else

            {

            iSettingMessage->Complete( aErr );

            delete iSettingMessage; iSettingMessage = NULL;      

            }                               

        }

    else

        {

        __LOG( "RcVolumeResponse - no msg" );

        }    

    }

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

// CUPnPPlaybackSession::RcSetMuteResponse

// See upnpplaybacksession.h

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

void CUPnPPlaybackSession::RcSetMuteResponse(

    const TDesC8& /*aUuid*/,

    TInt aSessionId,

    TInt aErr, 

    const TDesC8& /*aInstance*/, 

    const TDesC8& /*aChannel*/, 

    const TDesC8& aDesiredMute )

    {

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

    __ASSERTD( iIPSessionIdSetting == aSessionId, __FILE__, __LINE__ );

    iServer.Dispatcher().UnRegister( iIPSessionIdSetting );

    //iSettingPending = EFalse;

    iIPSessionIdSetting = KErrNotFound;

    if( iSettingMessage )

        {

        aErr = UPnPAVErrorHandler::ConvertToSymbianErrorCode( aErr,

            EUPnPRenderingControlError );    

        if( aErr == KErrNone )

            {

            TInt mute( EUnknown );

            TLex8 lex( aDesiredMute );

            TInt err = lex.Val( mute );

            // If mute's value isn't ENotMuted or EMuted, 

            // we think the value is incorrect.

            if ( err == KErrNone && mute != ENotMuted && mute != EMuted )

                {

                err = KErrArgument;

                }

            if(  err == KErrNone )

                {

                iMuteState = (TMuteState)mute;

                TPckg<TInt> resp2( mute );

                iSettingMessage->Write( 2, resp2 );

                iSettingMessage->Complete( EAVControllerSetMuteCompleted );

                delete iSettingMessage; iSettingMessage = NULL;            

                }

            else

                {

                iSettingMessage->Complete( err );

                delete iSettingMessage; iSettingMessage = NULL;      

                }    

            }

        else

            {

            iSettingMessage->Complete( aErr );

            delete iSettingMessage; iSettingMessage = NULL;      

            }                           

        }

    else

        {

        __LOG( "RcSetMuteResponse - no msg" );

        }    

    }

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

// CUPnPPlaybackSession::RcMuteResponse

// See upnpplaybacksession.h

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

void CUPnPPlaybackSession::RcMuteResponse(

    const TDesC8& /*aUuid*/,

    TInt aSessionId,

    TInt aErr, 

    const TDesC8& /*aInstance*/, 

    const TDesC8& /*aChannel*/, 

    const TDesC8& aCurrentMute )

    {

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

    __ASSERTD( iIPSessionIdSetting == aSessionId, __FILE__, __LINE__ );

    iServer.Dispatcher().UnRegister( iIPSessionIdSetting );

    iIPSessionIdSetting = KErrNotFound;

    if( iSettingMessage )

        {

        aErr = UPnPAVErrorHandler::ConvertToSymbianErrorCode( aErr,

            EUPnPRenderingControlError );

        if( aErr == KErrNone )

            {

            TInt mute( EUnknown );

            TLex8 lex( aCurrentMute );

            TInt err = lex.Val( mute );

            // If mute's value isn't ENotMuted or EMuted, 

            // we think the value is incorrect.

            if ( err == KErrNone && mute != ENotMuted && mute != EMuted )

                {

                err = KErrArgument;

                }

            if(  err == KErrNone )

                {

                iMuteState = (TMuteState)mute;

                TPckg<TInt> resp1( mute );

                iSettingMessage->Write( 1, resp1 );

                iSettingMessage->Complete( EAVControllerGetMuteCompleted );

                delete iSettingMessage; iSettingMessage = NULL;

                }

            else

                {

                iSettingMessage->Complete( err );

                delete iSettingMessage; iSettingMessage = NULL;

                }    

            }

        else

            {

            iSettingMessage->Complete( aErr );

            delete iSettingMessage; iSettingMessage = NULL;

            }                                   

        }

    else

        {

        __LOG( "RcMuteResponse - no msg" );

        }    

    }

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

// CUPnPPlaybackSession::AvtSetTransportUriResponse

// See upnpplaybacksession.h

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

void CUPnPPlaybackSession::AvtSetTransportUriResponse(

    const TDesC8& /*aUuid*/,

    TInt aSessionId,

    TInt aErr,

    const TDesC8& aInstanceId,

    const TDesC8& /*aCurrentUri*/,

    const TDesC8& /*aCurrentUriMetaData*/)

    {

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

    __ASSERTD( iIPSessionIdCommand == aSessionId, __FILE__, __LINE__ );  

    iServer.Dispatcher().UnRegister( iIPSessionIdCommand );