/*

* Copyright (c) 2005 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

#include "mussettings.h"

#include "musengmcesession.h"

#include "musengsessiondurationtimer.h"

#include "musengsessionobserver.h"

#include "musengmceutils.h"

#include "musuid.hrh"

#include "musenglogger.h"

#include "musengclipsessionobserver.h"

#include "mussipprofilehandler.h"

// SYSTEM

#include <mcedefs.h>

#include <mcemanager.h>

#include <mceinsession.h>

#include <mcevideostream.h>

#include <mceaudiostream.h>

#include <mcertpsink.h>

#include <mcedisplaysink.h>

#include <mcespeakersink.h>

#include <mcefilesource.h>

#include <mcertpsource.h>

#include <mceaudiocodec.h>

#include <mcevideocodec.h>

#include <AudioPreference.h>

const TInt KMusEngTimerInterval = 1000000; // 1 second

const TInt KMusEngRtcpInactivityThreshold = 20; // seconds

const TInt KMusEngArrayGranularity3 = 3;

const TInt KMusEngSipReasonCodeOk = 200;

const TInt KMusEngSipReasonCodeBusyHere = 486;

_LIT8( KMusEngSipReasonPhraseBusyHere, "Busy Here" );

_LIT8( KMusEngSipReasonPhraseBusy, "Busy" );

const TUint KMusEngDedicatedVideoPort = 49152;

const TUint KMusEngDedicatedAudioPort = 57344;

#define MUS_CODEC_ARR_CONST_CAST( codecArr ) \

( const_cast< RPointerArray< CMceVideoCodec >& >( codecArr ) )

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

//

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

//

CMusEngMceSession::~CMusEngMceSession()

    {

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

    delete iSipProfileHandler;

    delete iSession;

    delete iManager;

    delete iUpdateTimer;

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

    }

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

//

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

//

EXPORT_C void CMusEngMceSession::TerminateL()

    {

    MUS_LOG( "mus: [ENGINE]  -> CMusEngMceSession::TerminateL()" )

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

    iSession->TerminateL();

    MUS_LOG( "mus: [ENGINE]  <- CMusEngMceSession::TerminateL()" )

    }

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

// Returns estabilished session time. If not established return

// value is < 0

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

//

EXPORT_C TTimeIntervalSeconds CMusEngMceSession::GetSessionTime() const

    {

    if ( iSession && iSession->State() == CMceSession::EEstablished )

        {

        TTime time;

        TTimeIntervalSeconds seconds;

        time.HomeTime();

        time.SecondsFrom( iStartTime, seconds );

        return seconds;

        }

    return TTimeIntervalSeconds( KErrNotReady );

    }

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

//

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

//

EXPORT_C TBool CMusEngMceSession::ConnectionActive() const

    {

    if ( iSession )

        {

        return iSession->ConnectionActive();

        }

    return EFalse;

    }

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

//

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

//

EXPORT_C TBool CMusEngMceSession::ContainsAudioL()

    {

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

    for ( TInt i = 0; i < iSession->Streams().Count(); ++i )

        {

        if ( iSession->Streams()[i]->Type() == KMceAudio )

            {

            return ETrue;

            }

        }

    return EFalse;

    }

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

// 

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

//

EXPORT_C TBool CMusEngMceSession::IsMutedL()

    {

    // Precondition checked in ContainsAudioL

    if ( ContainsAudioL() && !iExplicitlyMuted )

        {

        return EFalse;

        }

    return ETrue;

    }

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

//

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

//

EXPORT_C CMusEngMceSession::TDisplayOrientation 

                                            CMusEngMceSession::OrientationL()

    {

    MUS_LOG( "mus: [ENGINE]  -> CMusEngMceSession::RotationL()" )

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

    CMceDisplaySink* display = MusEngMceUtils::GetDisplayL( *iSession );

    TDisplayOrientation displayOrientation;

    CMceDisplaySink::TRotation rotation( display->RotationL() );

    MUS_LOG1( "mus: [ENGINE]     MCE rotation is %d", rotation )

    if ( rotation == CMceDisplaySink::ENone )

        {

        displayOrientation = CMusEngMceSession::EPortrait;

        }

    else

        {

        displayOrientation = CMusEngMceSession::ELandscape;

        }

    MUS_LOG1( "mus: [ENGINE]  <- CMusEngMceSession::RotationL() %d", 

              displayOrientation )

    return displayOrientation;

    }

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

//

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

//        

EXPORT_C void CMusEngMceSession::SetOrientationL( 

                                        TDisplayOrientation aOrientation )

    {

    MUS_LOG1( "mus: [ENGINE]  -> CMusEngMceSession::SetOrientationL() %d", 

              aOrientation )

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

    CMceDisplaySink* display = MusEngMceUtils::GetDisplayL( *iSession );

    if ( aOrientation == EPortrait )

        {

        display->SetRotationL( CMceDisplaySink::ENone );

        }

    else

        {

        display->SetRotationL( CMceDisplaySink::EClockwise90Degree );

        }

    MUS_LOG( "mus: [ENGINE]  <- CMusEngMceSession::SetOrientationL()" )

    }

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

//

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

//

EXPORT_C void CMusEngMceSession::VolumeUpL()

    {

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

    CMusEngSession::VolumeUpL();

    SetSpeakerVolumeL( VolumeL() );

    }

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

//

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

//

EXPORT_C void CMusEngMceSession::VolumeDownL()

    {

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

    CMusEngSession::VolumeDownL();

    SetSpeakerVolumeL( VolumeL() );

    }

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

// 

// 

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

//

EXPORT_C void CMusEngMceSession::SetVolumeL( TInt aVal )

    {

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

    CMusEngSession::SetVolumeL( aVal );

    SetSpeakerVolumeL( VolumeL() );

    }

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

// 

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

//

EXPORT_C void CMusEngMceSession::EnableDisplayL( TBool aEnable )

    {

    MUS_LOG1( "mus: [ENGINE]     -> CMusEngMceSession::EnableDisplay() %d", 

              aEnable )

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

    CMceDisplaySink* display = MusEngMceUtils::GetDisplayL( *iSession );

    if ( aEnable )

        {

        if ( !display->IsEnabled() )

            {

            display->EnableL();

            MUS_LOG( "                  Display enabled" )

            if ( !iExplicitlyMuted )

                {

                // Since speaker is not explicitly muted, but disabled as

                // a consequence of disabling bundled display, it must be

                // unmuted.

                DoMuteSpeakerL( EFalse );

                MUS_LOG( "                  Bundled speaker enabled" )

                }

            }

        else

            {

            MUS_LOG( "                  Display already enabled, ignore" )

            }

        }

    else

        {

        if ( display->IsEnabled() )

            {

            display->DisableL();

            MUS_LOG( "                  Display disabled" )

            if ( !iExplicitlyMuted )

                {

                // Speaker will not be explicitly muted, but disabled as

                // a consequence of disabling bundled display.

                DoMuteSpeakerL( ETrue );

                MUS_LOG( "                  Bundled speaker disabled" )

                }

            }

        else

            {

            MUS_LOG( "                  Display already disabled, ignore" )

            }

        }

    MUS_LOG( "mus: [ENGINE]  <- CMusEngMceSession::EnableDisplay()")

    }

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

// Mutes playback of sended audio streams. Audio data is still streamed.

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

//

EXPORT_C void CMusEngMceSession::MuteL()

    {

    MUS_LOG( "mus: [ENGINE]  -> CMusEngMceSession::Mute()" )

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

    DoMuteSpeakerL( ETrue );

    // Mark speaker as explicitly muted instead of muted because of disabling

    // bundled display

    iExplicitlyMuted = ETrue; 

    MUS_LOG( "mus: [ENGINE]  <- CMusEngMceSession::Mute()" )

    }

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

// Unmutes playback of sended audio streams.

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

//

EXPORT_C void CMusEngMceSession::UnmuteL()

    {

    MUS_LOG( "mus: [ENGINE]  -> CMusEngMceSession::Unmute()" )

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

    DoMuteSpeakerL( EFalse );

    // Mark speaker as explicitly unmuted instead of unmuted because of 

    // enabling bundled display

    iExplicitlyMuted = EFalse;

    MUS_LOG( "mus: [ENGINE]  <- CMusEngMceSession::Unmute()" )

    }

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

//

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

//

CMusEngMceSession::CMusEngMceSession( const TRect& aRect,

                                      MMusEngSessionObserver& aSessionObserver )

    : CMusEngSession( aRect ),

      iSessionObserver( aSessionObserver ),

      iSecondsFromLastRtcpReport ( 0 ),

      // Although speaker is constructed as muted, it is not explicitly muted

      iExplicitlyMuted( EFalse ) 

    {

    }

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

//

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

//

void CMusEngMceSession::ConstructL()

    {

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

    CMusEngSession::ConstructL(); // Base class ConstructL -first

    // Creating new MCE Manager and set all needed observers to this class.

    iManager = CMceManager::NewL( TUid::Uid( KMusUiUid ),

                                  &iTransactionDataContainer );

    iManager->SetSessionObserver( this );

    iManager->SetInSessionObserver( this );

    iManager->SetMediaObserver( this );

    iManager->SetRtpObserver( this );

    // Check if operator specific behavior is expected

    iOperatorVariant = ( MultimediaSharingSettings::OperatorVariantSettingL() ==

                         MusSettingsKeys::EOperatorSpecific );

    // Update timer initialization

    iUpdateTimer = CMusEngSessionDurationTimer::NewL( *this );

  	iSipProfileHandler = CMusSipProfileHandler::NewL( *this );

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

    }

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

//

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

//

void CMusEngMceSession::RectChangedL()

    {

    MUS_LOG( "mus: [ENGINE]  -> CMusEngMceSession::RectChangedL()" )

    // If session is not yet created, do nothing

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

        {

        // Rely on having just one display

        CMceDisplaySink* display = MusEngMceUtils::GetDisplayL( *iSession );

        display->SetDisplayRectL( Rect() );

        }

    MUS_LOG( "mus: [ENGINE]  <- CMusEngMceSession::RectChangedL()" )

    }

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

// Setting session level sdp lines. Bandwith attribute is always used in

// operator variant mode and at receiver side (using force). 

// However, bandwidth attribute is preferred to be used at media level

// (see SetMediaSdpLinesL method). It is set to session level only if other

// side is using also session level bandwidth. Media level preference exists

// because some other manufacturer's videosharing does not understand session

// level bandwidth attribute.

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

//

void CMusEngMceSession::SetSessionSdpLinesL( 

    CMceSession& aSession, 

    TBool aForceBandwidthLine )

    {

    MUS_LOG( "mus: [ENGINE]  -> CMusEngMceSession::SetSessionSdpLinesL()" )

    MDesC8Array* oldSessionSdpLines = aSession.SessionSDPLinesL();

    CleanupDeletePushL( oldSessionSdpLines );

    TBool bandwidthAtSessionLevel( ContainsText( oldSessionSdpLines, 

                                   KMusEngSessionSdpLineBandwidthLine() ) );

    CleanupStack::PopAndDestroy( oldSessionSdpLines );

    CDesC8Array* newSessionSDPLines = 

                    new ( ELeave ) CDesC8ArrayFlat( KMusEngArrayGranularity3 );

    CleanupStack::PushL( newSessionSDPLines );

    if ( iOperatorVariant )

        {

        newSessionSDPLines->AppendL( KMusEngSessionSdpLineApplication() );

        newSessionSDPLines->AppendL( KMusEngSessionSdpLineType() );

        }

    else

    	{

    	newSessionSDPLines->AppendL( KMusEngSessionSdpLineXApplication() );	

    	}

    if ( bandwidthAtSessionLevel && ( iOperatorVariant || aForceBandwidthLine ) )

	    {

	    MUS_LOG( "mus: [ENGINE] setting bandwidth to session level" )

        newSessionSDPLines->AppendL( KMusEngSessionSdpLineBandwidthField() );

	    }

    aSession.SetSessionSDPLinesL( newSessionSDPLines );

    CleanupStack::Pop( newSessionSDPLines );

    MUS_LOG( "mus: [ENGINE]  <- CMusEngMceSession::SetSessionSdpLinesL()" )

    }

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

// Setting media level sdp lines. Bandwidth is not set to media level if

// it is used already at session level.

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

//

void CMusEngMceSession::SetMediaSdpLinesL( 

    CMceMediaStream& aStream, 

    TBool aForceBandwidthLine )

    {

    MUS_LOG( "mus: [ENGINE]  -> CMusEngMceSession::SetMediaSdpLinesL()" )

    MDesC8Array* sessionSdpLines = aStream.Session()->SessionSDPLinesL();

    CleanupDeletePushL( sessionSdpLines );

    TBool bandwidthAtSessionLevel( ContainsText( sessionSdpLines, 

                                   KMusEngSessionSdpLineBandwidthLine() ) );

    CleanupStack::PopAndDestroy( sessionSdpLines );

    if ( !bandwidthAtSessionLevel && ( iOperatorVariant || aForceBandwidthLine ) )

        {

    	MUS_LOG( "mus: [ENGINE] setting bandwidth to media level" )

		//Add media attribute to sdp

		const TInt KMusMediaSdpLinesGranularity = 1;

		CDesC8Array* headers = 

		    new ( ELeave ) CDesC8ArrayFlat( KMusMediaSdpLinesGranularity );

		CleanupStack::PushL( headers );

		headers->AppendL( KMusEngSessionSdpLineBandwidthField() );

		aStream.SetMediaAttributeLinesL( headers );   

		CleanupStack::Pop( headers );

        }

    MUS_LOG( "mus: [ENGINE]  <- CMusEngMceSession::SetMediaSdpLinesL()" )

    }

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

// Changes volume of all speaker sinks in the session structure

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

//

void CMusEngMceSession::SetSpeakerVolumeL( TInt aNewVolume )

    {

    TInt sessionState = iSession->State();

    if ( sessionState != CMceSession::EIdle &&

         sessionState != CMceSession::EIncoming )

        {

        for ( TInt i = 0; i < iSession->Streams().Count(); ++i )

            {

            CMceSpeakerSink* speaker = 

                MusEngMceUtils::GetSpeaker( *( iSession->Streams()[i] ) );