/*

* 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 the License "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 part of the engine. In practice keeps count on*

*/

// INCLUDE FILES

#include <pathinfo.h>

#include "VideoServiceUtilsConf.hrh" 

#include "CCREngine.h"

#include "CCRStreamingSession.h"

#include "CCRSession.h"

#include "CCRClientInformer.h"

#include "CCRConnection.h"

#ifdef RD_IPTV_FEA_RTP_CLIP_SUPPORT

#include <ipvideo/CRtpUtil.h>

#include <ipvideo/CRtpClipHandler.h>

#endif // RD_IPTV_FEA_RTP_CLIP_SUPPORT

#include <e32msgqueue.h>

#include <ipvideo/CRTypeDefs.h>

#include <e32std.h>

#include <es_sock.h>

#include "videoserviceutilsLogger.h"

// CONSTANTS

const TUint KCRELoopbackPortStart( 1106 );

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

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

// CCREngine::NewL

// Two-phased constructor.

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

//

CCREngine* CCREngine::NewL( void )

    {

    CCREngine* self = new( ELeave ) CCREngine();

    // Use CleanupClosePushL to make sure the Close function defined in CObject

    // base class gets called. CObject will delete itself once its reference count

    // reaches zero. Using CleanupStack::PushL here results in E32USER-CBase panic 33

    // if there is a leave somewhere in construction

    CleanupClosePushL( *self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CCREngine::CCREngine

// C++ default constructor can NOT contain any code, that might leave.

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

//

CCREngine::CCREngine( void ) : iLoopbackPort( KCRELoopbackPortStart )

    {

    // None

    }

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

// CCREngine::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CCREngine::ConstructL()

    {

    LOG( "CCREngine::ConstructL()" );

    // Note, quite high priority

    iCleanUp = new ( ELeave ) CAsyncCallBack( CActive::EPriorityStandard ); 

    }

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

// CCREngine::~CCREngine

// Destructor.

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

//

CCREngine::~CCREngine()

    {

    LOG( "CCREngine::~CCREngine()" );

    delete iCleanUp;

    iSessions.ResetAndDestroy();

    iSessionsToDelete.Reset(); 

    delete iConnection;

#ifdef RD_IPTV_FEA_RTP_CLIP_SUPPORT

    delete iClipHandler;

#endif // RD_IPTV_FEA_RTP_CLIP_SUPPORT

    iSockServer.Close(); 

    delete iInformer; 

    delete iQueueName;

    }

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

// Method for actual message handling.

//

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

//

void CCREngine::GeneralServiceL( const RMessage2& aMessage )

    {

#if defined( LIVE_TV_RDEBUG_TRACE ) || defined( LIVE_TV_FILE_TRACE )

    if ( aMessage.Function() != ECRGetPosition )

        {

        LOG1( "CCREngine::GeneralService(), aMessage: %d", aMessage.Function() );

        }

#endif // LIVE_TV_RDEBUG_TRACE || LIVE_TV_FILE_TRACE

    // Verify cababilities

    VerifyCapabilitiesL( aMessage );

    // Handle message

    TInt err( KErrNone );

    switch( aMessage.Function() )

        {

        case ECRSetIap:

            {

            TPckgBuf<SCRRtspIapParams> pckg;

            Read( aMessage, 0, pckg );

            err = SetConnectionId( pckg() );  

            aMessage.Complete( err );

            }

            break;      

        case ECRCancelSetIap:

            aMessage.Complete( CancelSetConnectionId() );

            break;

        case ECRPlayRtspUrl:

            {

            TPckgBuf<TUint> pckg0( 0 );

            TPckgBuf<SCRRtspParams> pckg1;

            Read( aMessage, 1, pckg1 );

            TRAP( err, pckg0() = PlayRtspUrlL( pckg1() ) );

            if ( !err )

                {

                Write( aMessage, 0, pckg0 );

                }

            aMessage.Complete( err );

            }

            break;      

        case ECRPlayDvbhLive:

            {

            TPckgBuf<TUint> pckg0( 0 );

            TPckgBuf<SCRLiveParams> pckg1;

            Read( aMessage, 1, pckg1 );

            TRAP( err, pckg0() = PlayDvbhLiveL( pckg1() ) );

            if ( !err )    

                {

                Write( aMessage, 0, pckg0 );

                }

            aMessage.Complete( err );

            }

            break;      

        case ECRChangeService:

            {

            TPckgBuf<TUint> pckg0( 0 );

            TPckgBuf<SCRLiveParams> pckg1;

            Read( aMessage, 0, pckg0 );

            Read( aMessage, 1, pckg1 );

            TRAP( err, pckg0() = ChangeDvbhServiceL( pckg0(), pckg1() ) );

            if ( !err )    

                {

                Write( aMessage, 0, pckg0 );

                }

            aMessage.Complete( err );

            }

            break;

        case ECRPlayRtpFile:

            {

            TPckgBuf<TUint> pckg0( 0 );

            TPckgBuf<SCRRtpPlayParams> pckg1;

            Read( aMessage, 1, pckg1 );

            TRAP( err, pckg0() = PlayRtpFileL( pckg1() ) );

            if ( !err )

                {

                Write( aMessage, 0, pckg0 );

                }

            aMessage.Complete( err );

            }

            break;      

        case ECRPlayRtpHandle:

            {

            RFile fileHandle;

            err = fileHandle.AdoptFromClient( aMessage, 1, 2 );

            if ( !err )

                {

                TPckgBuf<TUint> pckg( 0 );

                TRAP( err, pckg() = PlayRtpFileL( fileHandle ) );

                if ( !err )

                    {

                    Write( aMessage, 0, pckg );

                    }

                }

            fileHandle.Close();

            aMessage.Complete( err );

            }

            break;      

        case ECRRecordCurrentStream:

            {

            TPckgBuf<TUint> pckg0( 0 );

            Read( aMessage, 0, pckg0 );

            TPckgBuf<SCRRecordParams> pckg1;

            Read( aMessage, 1, pckg1 );

            TRAP( err, RecordCurrentStreamL( pckg0(), pckg1() ) );

            aMessage.Complete( err );

            }

            break;

        case ECRRecordRtspStream:

            {

            TPckgBuf<TUint> pckg0( 0 );

            TPckgBuf<SCRRtspParams> pckg1;

            Read( aMessage, 1, pckg1 );

            TPckgBuf<SCRRecordParams> pckg2;

            Read( aMessage, 2, pckg2 );

            TRAP( err, pckg0() = RecordRtspStreamL( pckg1(), pckg2() ) );

            aMessage.Complete( err );

            }

            break;

        case ECRRecordDvbhStream:

            {

            TPckgBuf<TUint> pckg0( 0 );

            TPckgBuf<SCRLiveParams> pckg1;

            Read( aMessage, 1, pckg1 );

            TPckgBuf<SCRRecordParams> pckg2;

            Read( aMessage, 2, pckg2 );

            TRAP( err, pckg0() = RecordDvbhStreamL( pckg1(), pckg2() ) );

            aMessage.Complete( err );

            }

            break;

        case ECRPauseRecordStream:

            {

            TPckgBuf<TUint> pckg0( 0 );

            Read( aMessage, 0, pckg0 );

            TPckgBuf<TBool> pckg1( 0 );

            Read( aMessage, 1, pckg1 );

            aMessage.Complete( PauseRecordStream( pckg0(), pckg1() ) );

            }

            break;

        case ECRStopRecordStream:

            {

            TPckgBuf<TUint> pckg0( 0 );

            Read( aMessage, 0, pckg0 );

            aMessage.Complete( StopRecordStream( pckg0() ) );

            }

            break;

        case ECRStartTimeShift:

            {

            TPckgBuf<TUint> pckg0( 0 );

            TPckgBuf<TUint> pckg1( 0 );

            Read( aMessage, 1, pckg1 );

            TRAP( err, pckg0() = StartTimeShiftL( pckg1() ) );

            if ( !err )

                {

                Write( aMessage, 0, pckg0 );

                }

            aMessage.Complete( err );

            }

            break;

        case ECRStopTimeShift:

            {

            TPckgBuf<TUint> pckg0( 0 );

            TPckgBuf<TUint> pckg1( 0 );

            Read( aMessage, 0, pckg0 );

            Read( aMessage, 1, pckg1 );

            aMessage.Complete( StopTimeShift( pckg0(), pckg1() ) );

            }

            break;

        case ECRPlayCommand:

            {

            TPckgBuf<TUint> pckg0( 0 );

            Read( aMessage, 0, pckg0 );

            TPckgBuf<TInt64> pckg1( 0 );

            Read( aMessage, 1, pckg1 );

            TPckgBuf<TInt64> pckg2( 0 );

            Read( aMessage, 2, pckg2 );

            aMessage.Complete( PlayCommand( pckg0(), pckg1(), pckg2() ) );

            }

            break;

        case ECRPauseCommand:

            {

            TPckgBuf<TUint> pckg0( 0 );

            Read( aMessage, 0, pckg0 );

            aMessage.Complete( PauseCommand( pckg0() ) );

            }

            break;

        case ECRStopCommand:

            {

            TPckgBuf<TUint> pckg0( 0 );

            Read( aMessage, 0, pckg0 );

            aMessage.Complete( StopCommand( pckg0() ) );

            }

            break;

        case ECRSetPosition:

            {

            TPckgBuf<TUint> pckg0( 0 );

            Read( aMessage, 0, pckg0 );

            TPckgBuf<TInt64> pckg1( 0 );

            Read( aMessage, 1, pckg1 );

            err = SetPosition( pckg0(), pckg1() );

            aMessage.Complete( err );

            }

            break;

        case ECRGetPosition:

            {

            TPckgBuf<TUint> pckg0( 0 );

            Read( aMessage, 0, pckg0 );

            TPckgBuf<TInt64> pckg1( 0 );

            Read( aMessage, 1, pckg1 );

            TPckgBuf<TInt64> pckg2( 0 );

            err = GetPosition( pckg0(), pckg1(), pckg2() );

            Write( aMessage, 1, pckg1 );

            Write( aMessage, 2, pckg2 );

            aMessage.Complete( err );

            }

            break;

        case ECRCloseSession:

            {

            TPckgBuf<TUint> pckg0( 0 );

            Read( aMessage, 0, pckg0 );

            aMessage.Complete( CloseSession( pckg0() ) );

            }

            break;

        case ECRPlayNullSource:

            {

            TPckgBuf<TUint> pckg0( 0 );

            TRAP( err, pckg0() = PlayNullSourceL() );

            Write( aMessage, 0, pckg0 );

            aMessage.Complete( err );

            }

            break;     

        case ECRPlayRtspUrlToNullSink:

            {

            TPckgBuf<TUint> pckg0( 0 );

            TPckgBuf<SCRRtspParams> pckg1;

            Read( aMessage, 1, pckg1 );

            TRAP( err, pckg0() = PlayRtspUrlToNullSinkL( pckg1() ) );

            Write( aMessage, 0, pckg0 );

            aMessage.Complete( err );

            }

            break;     

        default:

            aMessage.Complete( KErrNotSupported ); 

            break; 

        }

    }

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

// CCREngine::SessionStop()

// So, a session wants to quit. we can't just delete it here as return.

// Statement would then take us to deleted instance: put up a cleanup 

// CAsyncCallBack and return.

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

//

void CCREngine::SessionStop( CCRStreamingSession* aSession )

    {

    LOG1( "CCREngine::SessionStop(), Delete count: %d", iSessionsToDelete.Count() );    

    // InsertInAddressOrder checks for duplicate, if there is already

    // entry for that session, the array will remain unchanged

    TRAPD( err, iSessionsToDelete.InsertInAddressOrderL( aSession ) ); 

    if ( err )

        {

        LOG1( "CCREngine::SessionStop(), InsertInAddressOrder leaved: %d", err );      

        }

    // If not already active and sessions to delete?

    if ( !iCleanUp->IsActive() && iSessionsToDelete.Count() ) 

        {

        TCallBack cb( SessionStopCallBack, this );

        iCleanUp->Set( cb );

        iCleanUp->CallBack();

        }               

    }

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

// CCREngine::ConnectionStatusChange

//

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

//

void CCREngine::ConnectionStatusChange(

    TInt aSessionId,

    TCRConnectionStatus aStatus,

    TInt aErr )

    {

    LOG3( "CCREngine::ConnectionStatusChange(), aSessionId: %d, aStatus: %d, Error: %d",

                                                aSessionId, aStatus, aErr );

    SCRQueueEntry entry = { ECRMsgQueueConnectionError, KErrNone };

    entry.iSessionId = aSessionId;

    switch ( aStatus )

        {           

        case ECRConnectionError:

            {               

            entry.iMsg = ECRMsgQueueConnectionError;

            entry.iErr = aErr;

            }

            break;

        case ECRAuthenticationNeeded:

            {               

            entry.iMsg = ECRMsgQueueAuthenticationNeeded;

            entry.iErr = KErrNone;

            }      

            break;  

        case ECRNotEnoughBandwidth:

            {               

            entry.iMsg = ECRMsgQueueNotEnoughBandwidth;

            entry.iErr = KErrNone;

            }      

            break;  

        case ECRNormalEndOfStream:

            {               

            entry.iMsg = ECRMsgQueueNormalEndOfStream;

            entry.iErr = aErr;

            }

            break;

        case ECRAttachCompleted: // fall through

        case ECRSwitchingToTcp:

            {               

            aStatus == ECRAttachCompleted ? 

                           ( entry.iMsg = ECRMsgQueueAttachCompleted ) :

                           ( entry.iMsg = ECRMsgQueueSwitchingToTcp );

            if ( aErr == KErrNone )

                {

                // Releasing RSocket takes almost 40 seconds so we need 

                // to always use different port number, otherwise an  

                // "Already in use" error will be occurred.

                TTime now;

                now.UniversalTime();                  

                TInt port = KCRELoopbackPortStart + now.DateTime().Second();   

                iLoopbackPort == port ? ( iLoopbackPort = port + 1 ) : 

                                        ( iLoopbackPort = port );

                // Loopback port for VIA

                entry.iErr = iLoopbackPort;

                }

            else

                {

                entry.iErr = aErr;

                }

            }           

            break;  

        case ECRStreamIsLiveStream:

            {

            entry.iMsg = ECRMsgQueueStreamIsLiveStream; 

            entry.iErr = aErr; 

            }

            break; 

        case ECRStreamIsRealMedia:

            {

            entry.iMsg = ECRMsgQueueStreamIsRealMedia; 

            entry.iErr = aErr; 

            }

            break; 

        case ECRBearerChanged:

            {

            // Nobody is interested about this on the other side...

            return;         

            }

        case ECRTestSinkData:

            {

            entry.iMsg = ECRMsgQueueTestSinkData;

            entry.iErr = aErr;

            }

            break;

        case ECRSdpAvailable:

            {

            entry.iMsg = ECRMsgQueueSdpAvailable;

            entry.iErr = aErr;

            }

            break;

        case ECRReadyToSeek:

            {

            entry.iMsg = ECRMsgQueueReadyToSeek; 

            entry.iErr = aErr; 

            }

            break; 

        case ECRRecordingStarted:

            {

            entry.iMsg = ECRMsgQueueRecordingStarted;

            entry.iErr = aErr;

            }

            break;