/*

* 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 "musengsessionobserver.h"

#include "musengreceivesessionobserver.h"

#include "musengmceutils.h"

#include "musenglogger.h"

#include "mussettings.h"

#include "mussipprofilehandler.h"

// SYSTEM INCLUDES

#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 <utf.h>

const TUint8 KMusEngRtpKeepAliveTimer = 5; // this should be 30 sec, this a temporary fix

const TUint8 KMusEngKeepAlivePayloadTypeVideoH263 = 96;

const TUint8 KMusEngKeepAlivePayloadTypeAudio = 97;

const TUint8 KMusEngKeepAlivePayloadTypeVideoAvc = 98;

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 KMusEngOneSecondInMilliSeconds = 1000; 

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

const TUint KMusEngInactivityTimer = KMusEngTresholdToSecondsFactor * 

                                     KMusEngJitterBufferTreshold + 

                                     KMusEngOneSecondInMilliSeconds;

_LIT8( KMusEngSwisIdentifier, "Require: precondition" );

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

_LIT8( KMusEngBiggerSign, ">" );

const TInt KMusEngSipReasonCodeBusyHere = 486;

_LIT8( KMusEngSipReasonPhraseBusy, "Busy" );

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

//

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

//

CMusEngReceiveSession::~CMusEngReceiveSession()

    {

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

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

    }

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

//

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

//

EXPORT_C CMusEngReceiveSession* CMusEngReceiveSession::NewL(

                        const TRect& aRect,

                        MMusEngSessionObserver& aSessionObserver,

                        MMusEngReceiveSessionObserver& aReceiveSessionObserver )

    {

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

    CMusEngReceiveSession* self = new( ELeave ) CMusEngReceiveSession( 

                                                        aSessionObserver, 

                                                        aReceiveSessionObserver,

                                                        aRect );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

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

    return self;

    }

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

//

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

//

EXPORT_C void CMusEngReceiveSession::AcceptInvitationL(

                        const TBool& aAccept )

    {

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

              AcceptInvitationL( %d )", aAccept )

    __ASSERT_ALWAYS( iSession && iSession->State() == CMceSession::EProceeding,

                     User::Leave( KErrNotReady ) );

    // Accept or reject

    if ( aAccept )

        {

        InSession()->AcceptL();

        }

    else

        {

        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();

            }

        }

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

             AcceptInvitationL(...)" )

    }

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

// 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;

            // Notify user

            TBuf16<KMaxUriLength> originator;

            CnvUtfConverter::ConvertToUnicodeFromUtf8( originator,

                                                       iSession->Originator() );

            TBuf16<KMaxUriLength> identity;

            CnvUtfConverter::ConvertToUnicodeFromUtf8( identity,

                                                       iIdentity );                                                       

            iReceiveSessionObserver.IncomingSession( originator, identity );

            }

        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 )

    {

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

    CMusEngMceSession::AdjustVideoCodecL( aVideoCodec );

    aVideoCodec.SetKeepAliveTimerL( KMusEngRtpKeepAliveTimer );

    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( KMusEngRtpKeepAliveTimer );

    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() && 

             !MultimediaSharingSettings::IsAvcDisabled() )

            { 

            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;

        }

    iReceiveSessionObserver.IncomingSessionPreNotification();

    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 )

            {

            iReceiveSessionObserver.StreamBuffering();

            }

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

            {

            CMceRtpSource* rtpSource = 

                            static_cast<CMceRtpSource*>( aStream.Source() );

            TRAPD( err , 

                  rtpSource->EnableInactivityTimerL( KMusEngInactivityTimer ) );

            if ( err != KErrNone )

                {

                MUS_LOG1("mus: [ENGINE] EnableInactivityTimerL Fails %d",err)

                iSessionObserver.SessionFailed();    

                }

            else

                {

                iSessionObserver.StreamStreaming();

                }            

            }

        else

            {

            // Cannot handle, forward to CMusEngMceSession

            CMusEngMceSession::StreamStateChanged( aStream );

            }

        }

    else

        {

        // Cannot handle, forward to CMusEngMceSession

        CMusEngMceSession::StreamStateChanged( aStream );

        }

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

    }

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

//

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

//

CMusEngReceiveSession::CMusEngReceiveSession(

                        MMusEngSessionObserver& aSessionObserver,

                        MMusEngReceiveSessionObserver& aReceiveSessionObserver,

                        const TRect& aRect )

    : CMusEngMceSession( aRect, aSessionObserver ),

      iReceiveSessionObserver( aReceiveSessionObserver )

    {

    }

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

//

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

//

void CMusEngReceiveSession::ConstructL()

    {

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

    CMusEngMceSession::ConstructL();

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

    }

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

//

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

//

CMceInSession* CMusEngReceiveSession::InSession()

    {

    return static_cast<CMceInSession*>(iSession);

    }

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

// Check if incoming session is originated from VideoSharing 2.2 client, 

// which sends PRACK for 180 Ringing whether it is required or not. In 

// order to let MCE handle the PRACK correctly, force 180 Ringing to be 

// sent reliably.

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

//

void CMusEngReceiveSession::PrepareToRequire100RelL( 

                    TMceTransactionDataContainer* aContainer)

    {

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

    __ASSERT_ALWAYS( aContainer, User::Leave( KErrArgument ) );

    CDesC8Array* headers = aContainer->GetHeaders();