/*

* 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: 

*

*/

// USER INCLUDES

#include "musengreceivesession.h"

#include "musengmceutils.h"

#include "musenglogger.h"

#include "mussipprofilehandler.h"

#include "mussessionproperties.h"

#include "musengremotevideoplayer.h"

// SYSTEM INCLUDES

#include <lcsessionobserver.h>

#include <mcemanager.h>

#include <mceinsession.h>

#include <mcestreambundle.h>

#include <mceaudiostream.h>

#include <mcevideostream.h>

#include <mcemediasource.h>

#include <mcertpsource.h>

#include <mcedisplaysink.h>

#include <mcespeakersink.h>

#include <mceaudiocodec.h>

#include <mceavccodec.h>

#include <e32property.h>

#include <utf.h>

const TInt KMusEngJitterBufferLength = 51; //Must be bigger than treshold

// Using following value increases treshold buffer to 1 second from 

// default 100 ms

const TInt KMusEngJitterBufferTreshold = 50;

const TInt KMusEngTresholdToSecondsFactor = 20;

const TInt KMusEngTwoSecondInMilliSeconds = 2000; 

// Use inactivity timer value that is a little bigger than treshold in seconds

const TUint KMusEngInactivityTimer = KMusEngTresholdToSecondsFactor * 

                                     KMusEngJitterBufferTreshold + 

                                     KMusEngTwoSecondInMilliSeconds;

_LIT8( KMusEngSwisIdentifier, "Require: precondition" );

_LIT8( KMusEngAssertedIdentity, "P-Asserted-Identity" );

_LIT8( KMusEngBiggerSign, ">" );

const TInt KMusEngSipReasonCodeBusyHere = 486;

_LIT8( KMusEngSipReasonPhraseBusy, "Busy" );

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

//

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

//

CMusEngReceiveSession* CMusEngReceiveSession::NewL()

    {

    MUS_LOG( "mus: [ENGINE]  -> CMusEngReceiveSession::NewL(...)" )

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    MUS_LOG( "mus: [ENGINE]  <- CMusEngReceiveSession::NewL(...)" )

    return self;

    }

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

//

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

//

CMusEngReceiveSession::CMusEngReceiveSession()

    : CMusEngMceSession()

    {

    }

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

//

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

//

void CMusEngReceiveSession::ConstructL()

    {

    MUS_LOG( "mus: [ENGINE]  -> CMusEngReceiveSession::ConstructL()" )

    CMusEngMceSession::ConstructL();

    iOriginator = HBufC8::NewL( KMaxUriLength );

    iRemoteDisplayName = HBufC::NewL( KMaxUriLength );

    iRemoteVideoPlayer = CMusEngRemoteVideoPlayer::NewL( *this, *this );

    iReceivingInactivityTimeout = KMusEngInactivityTimer;

    iKeepaliveTimer = KMusEngRtpKeepAliveTimer;

    MUS_LOG( "mus: [ENGINE]  <- CMusEngReceiveSession::ConstructL()" )

    }

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

//

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

//

CMusEngReceiveSession::~CMusEngReceiveSession()

    {

    MUS_LOG( "mus: [ENGINE]  -> CMusEngReceiveSession::~CMusEngReceiveSession()" )

    if ( iOriginator )

        {

        TRAP_IGNORE( SaveContactL( *iOriginator ) )

        }

    delete iOriginator;

    delete iRemoteDisplayName;

    delete iRemoteVideoPlayer;

    MUS_LOG( "mus: [ENGINE]  <- CMusEngReceiveSession::~CMusEngReceiveSession()" )

    }

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

// From MLcSession

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

//

MLcSession::TLcSessionState CMusEngReceiveSession::LcSessionState() const

    {

    TLcSessionState state = CMusEngMceSession::LcSessionState();

    if ( !iSession && state == MLcSession::EUninitialized )

        {

        state = MLcSession::EReceived;

        }

    return state;

    }

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

// From MLcSession

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

//

void CMusEngReceiveSession::EstablishLcSessionL()

    {

    MUS_LOG( "mus: [ENGINE]  -> CMusEngReceiveSession::EstablishLcSessionL" )

    __ASSERT_ALWAYS( iSession, User::Leave( KErrNotReady ) );

    InSession()->AcceptL();

    MUS_LOG( "mus: [ENGINE]  <- CMusEngReceiveSession::EstablishLcSessionL" )

    }

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

// From MLcSession

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

//

void CMusEngReceiveSession::TerminateLcSessionL()

    {

    MUS_LOG( "mus: [ENGINE]  -> CMusEngReceiveSession::EstablishLcSessionL" )

    __ASSERT_ALWAYS( iSession, User::Leave( KErrNotReady ) );

    if ( iSession->State() == CMceSession::EIncoming ||

         iSession->State() == CMceSession::EProceeding )

        {

        // Reject

        if ( iOperatorVariant )

            {

            // In operator variant, session is rejected with 486 instead of 603.

            // Also the reason phrase is supposed to be "Busy".

            InSession()->RejectL( KMusEngSipReasonPhraseBusy(), 

                                  KMusEngSipReasonCodeBusyHere );

            }

        else

            {

            InSession()->RejectL();

            }

        }

    else

        {

        iSession->TerminateL();

        }

    MUS_LOG( "mus: [ENGINE]  <- CMusEngReceiveSession::EstablishLcSessionL" )

    }

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

// From MLcSession

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

//

MLcVideoPlayer* CMusEngReceiveSession::RemoteVideoPlayer()

    {

    return iRemoteVideoPlayer;

    }

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

// From MLcSession

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

//

const TDesC& CMusEngReceiveSession::RemoteDisplayName()

    {

    TBuf<RProperty::KMaxPropertySize> buffer;

    TInt error = RProperty::Get( NMusSessionApi::KCategoryUid,

                                 NMusSessionApi::KContactName,

                                 buffer );

    if ( error == KErrNone && buffer.Length() )

        {

        iRemoteDisplayName->Des().Copy( buffer );

        }

    else if ( iOriginator )

        {

        iRemoteDisplayName->Des().Copy(*iOriginator);   

        }

    return *iRemoteDisplayName;

    }

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

// When reserving resources is ready, this function reports observer about

// incoming session and signals this also to other end terminal ( 180 ringing ).

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

//

void CMusEngReceiveSession::HandleSessionStateChanged(

                                        CMceSession& aSession,

                                        TInt aStatusCode,

                                        const TDesC8& aReasonPhrase )

    {

    MUS_LOG( "mus: [ENGINE]  -> CMusEngReceiveSession::\

             HandleSessionStateChanged()" )

    MUS_ENG_LOG_SESSION_STATE_AND_STATUS( aSession, aStatusCode, aReasonPhrase )

    if ( iSession && 

         iSession == &aSession &&

         aSession.State() == CMceSession::EProceeding )

        {

        // Indicates that resource reservation is ready, user can be notified

        // if we do not have to wait for PRACK

        if ( !iRingLCalled )

            {

            // Notify other end terminal

            TRAP_IGNORE( InSession()->RingL() )

            iRingLCalled = ETrue;

            TPtr8 ptrOriginator( iOriginator->Des() );

            ptrOriginator.Copy( iSession->Originator() );

            InformObserverAboutSessionStateChange();

            }

        else

            {

            MUS_LOG( "mus: [ENGINE]     User and remote end already notified." )

            }

        }

    else

        {

        // Forward all other session state changes to base class

        CMusEngMceSession::HandleSessionStateChanged( aSession,

                                                      aStatusCode,

                                                      aReasonPhrase );

        }

    MUS_LOG( "mus: [ENGINE]  <- CMusEngReceiveSession::\

             HandleSessionStateChanged()" )

    }

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

// Sets keepalive timer for video and calls base class variant of this function

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

//

void CMusEngReceiveSession::AdjustVideoCodecL( CMceVideoCodec& aVideoCodec,

                                               TMceSourceType aSourceType )

    {

    MUS_LOG( "mus: [ENGINE]  -> CMusEngReceiveSession::AdjustVideoCodecL()" )

    CMusEngMceSession::AdjustVideoCodecL( aVideoCodec, aSourceType );

    MUS_LOG1( "mus: [ENGINE]     Keepalive timer:%d", iKeepaliveTimer )

    aVideoCodec.SetKeepAliveTimerL( iKeepaliveTimer );

    if ( aVideoCodec.SdpName() == KMceSDPNameH263() ||

         aVideoCodec.SdpName() == KMceSDPNameH2632000() )

        {

        aVideoCodec.SetKeepAlivePayloadTypeL( KMusEngKeepAlivePayloadTypeVideoH263 );

        }

    else if ( aVideoCodec.SdpName() == KMceSDPNameH264() )

        {

        aVideoCodec.SetKeepAlivePayloadTypeL( KMusEngKeepAlivePayloadTypeVideoAvc );

        }

    else

        {

        // NOP

        }

    aVideoCodec.SetKeepAliveDataL( KNullDesC8() );

    MUS_LOG( "mus: [ENGINE]  <- CMusEngReceiveSession::AdjustVideoCodecL()" )

    }

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

// Sets keepalive timer for audio and calls base class variant of this function

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

//        

void CMusEngReceiveSession::AdjustAudioCodecL( CMceAudioCodec& aAudioCodec )

    {

    MUS_LOG( "mus: [ENGINE]  -> CMusEngReceiveSession::AdjustAudioCodecL()" )

    CMusEngMceSession::AdjustAudioCodecL( aAudioCodec );

    aAudioCodec.SetKeepAliveTimerL( iKeepaliveTimer );

    aAudioCodec.SetKeepAlivePayloadTypeL( KMusEngKeepAlivePayloadTypeAudio );

    aAudioCodec.SetKeepAliveDataL( KNullDesC8() );

    MUS_LOG( "mus: [ENGINE]  <- CMusEngReceiveSession::AdjustAudioCodecL()" )

    }

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

// 

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

//

void CMusEngReceiveSession::DoCodecSelectionL( CMceVideoStream& aVideoStream )

    {

    MUS_LOG( "mus: [ENGINE]  -> CMusEngReceiveSession::DoCodecSelectionL()" )

    const RPointerArray<CMceVideoCodec>& codecs = aVideoStream.Codecs();

    const CMceVideoCodec* avcSingleNal = NULL;

    const CMceVideoCodec* avcNonInterleaved = NULL;

    for ( TInt codecIndex = 0; codecIndex < codecs.Count(); ++codecIndex )

        {

        if ( codecs[codecIndex]->SdpName() == KMceSDPNameH264() )

            { 

            if ( codecs[codecIndex]->CodecMode() == KMceAvcModeSingleNal )

                {

                // Store a pointer to the Single NAL codec with best bitrate

                if ( !avcSingleNal || 

                     ( avcSingleNal && codecs[codecIndex]->MaxBitRate() > 

                                       avcSingleNal->MaxBitRate() ) )

                    {

                    avcSingleNal = codecs[codecIndex];

                    }

                }  

            else if ( codecs[codecIndex]->CodecMode() == 

                                                KMceAvcModeNonInterleaved )

                {

                // Store a pointer to the Non-Interleaved codec with best bitrate

                if ( !avcNonInterleaved || 

                     ( avcNonInterleaved && codecs[codecIndex]->MaxBitRate() > 

                                            avcNonInterleaved->MaxBitRate() ) )

                    {

                    avcNonInterleaved = codecs[codecIndex];

                    }

                }

            else 

                {

                // NOP, we do not care about interleaved AVC

                }

            }

        }

    const CMceVideoCodec* selectedCodec = NULL;

    if ( avcNonInterleaved )

        {

        selectedCodec = avcNonInterleaved;

        }

    else

        {

        selectedCodec = avcSingleNal;

        }

    if ( selectedCodec )

        {

        // Remove all other codecs

        for ( TInt codecIndex = 0; codecIndex < codecs.Count(); ++codecIndex )

            {

            if ( codecs[codecIndex] != selectedCodec )

                {

                aVideoStream.RemoveCodecL( *codecs[codecIndex] );

                // Since succesfull removal of a codec has decreased the amount

                // of codecs in array by one, we have to reset the index

                codecIndex = 0;

                }

            }   

        }

    else

        {

        // Let the base class do H.263 selection

        CMusEngMceSession::DoCodecSelectionL( aVideoStream );

        }

    MUS_LOG( "mus: [ENGINE]  <- CMusEngReceiveSession::DoCodecSelectionL()" )

    }

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

// If incoming session does not have valid structure and cannot be reconstructed

// as such, session is rejected automatically.

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

//

void CMusEngReceiveSession::IncomingSession(

    CMceInSession* aSession,

    TMceTransactionDataContainer* aContainer )

    {

    MUS_LOG( "mus: [ENGINE]  -> CMusEngReceiveSession::IncomingSession(...)" )

    if ( !aContainer || 

         ( iSession &&

           iSession->State() != CMceSession::ETerminated ) )

        {

        // We already have one session ongoing, or do not have container. 

        // Reject new session.

        Reject( *aSession );

        delete aSession;

        aSession = NULL;

        MUS_LOG( "mus: [ENGINE]  <- CMusEngReceiveSession::IncomingSession( \

                 session already exists. New session rejected and deleted. )" )

        return;

        }

    delete iSession; // possibly existing terminated session

    iSession = aSession;

    if ( iOperatorVariant )

        {

        ParseAssertedIdentity( aContainer );    

        }

    // Reset variable defined for preparing for multiple state changes to

    // EProceeding. This might happen if we set 100rel to be required. 

    iRingLCalled = EFalse;

    // If preparing fails, session setup with VS2.2 will fail later

    TRAP_IGNORE( PrepareToRequire100RelL( aContainer ) )

    TRAPD( error, CompleteSessionStructureL() );

    if ( error != KErrNone )

        {

        Reject( *InSession() );

        }

    MUS_LOG( "mus: [ENGINE]  <- CMusEngReceiveSession::IncomingSession()" )

    }

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

//

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

//

void CMusEngReceiveSession::IncomingUpdate(

    CMceSession& aOrigSession,

    CMceInSession* aUpdatedSession,

    TMceTransactionDataContainer* aContainer )

    {

    MUS_LOG( "mus: [ENGINE]  -> CMusEngReceiveSession::IncomingUpdate(...)" )

    if ( iSession &&

         iSession == &aOrigSession )

        {

        // Old session is useless from now on

        delete iSession;

        iSession = aUpdatedSession;

        TRAPD( error, CompleteSessionStructureL() );

        if ( error != KErrNone )

            {

            MUS_LOG( "mus: [ENGINE]  Cannot handle update, reject" )

            Reject( *aUpdatedSession );

            }

        }

    else

        {

        // Cannot handle, forward to a base class

        CMusEngMceSession::IncomingUpdate( aOrigSession,

                                           aUpdatedSession,

                                           aContainer );

        }

    MUS_LOG( "mus: [ENGINE]  <- CMusEngReceiveSession::IncomingUpdate(...)" )

    }

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

//

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

//

void CMusEngReceiveSession::StreamStateChanged( CMceMediaStream& aStream )

    {

    MUS_LOG( "mus: [ENGINE] -> CMusEngReceiveSession::StreamStateChanged()" )

    MUS_ENG_LOG_STREAM_STATE( aStream )

    if ( !iSession )

        {

        return;

        }

    if ( aStream.Type() == KMceVideo &&

         aStream.Source() &&

         aStream.Source()->Type() == KMceRTPSource )

        {

        if ( aStream.State() == CMceMediaStream::EBuffering )

            {

            iBuffered = ETrue;

            InformObserverAboutPlayerStateChange( iRemoteVideoPlayer );

            }

        else if ( aStream.State() == CMceMediaStream::EStreaming )

            {

            ReceivingStarted();          

            }

        else

            {

            // Cannot handle, forward to CMusEngMceSession

            CMusEngMceSession::StreamStateChanged( aStream );

            }

        }

    else

        {

        // Cannot handle, forward to CMusEngMceSession

        CMusEngMceSession::StreamStateChanged( aStream );

        }