/*

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

#include "musuid.hrh"

#include "musenglogger.h"

#include "mussipprofilehandler.h"

#include "mussessionproperties.h"

#include "musenguriparser.h"

#include "musengtelephoneutils.h"

// SYSTEM

#include <lcsessionobserver.h>

#include <lcuiprovider.h>

#include <lcvideoplayer.h>

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

#include <mcertpsource.h>

#include <mceaudiocodec.h>

#include <mceavccodec.h>

#include <AudioPreference.h>

#include <e32property.h>

#include <cntitem.h>

#include <cntfield.h>

#include <cntdef.h>

#include <cntfldst.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 ) )

// Names of AVC levels in string for config keys stored in CenRep 

_LIT8( KMusAvcBitrateLevel1, "AvcBrL1=" );

_LIT8( KMusAvcBitrateLevel1b, "AvcBrL1b=" );

_LIT8( KMusAvcBitrateLevel1_1, "AvcBrL1_1=" );

_LIT8( KMusAvcBitrateLevel1_2, "AvcBrL1_2=" );

_LIT8( KMusAvcBitrateLevel1_3, "AvcBrL1_3=" );

_LIT8( KMusAvcBitrateLevel2, "AvcBrL2=" );

_LIT8( KMusEncoderInfoTokenizer, ";" );

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

//

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

//

CMusEngMceSession::CMusEngMceSession()

    : iSecondsFromLastRtcpReport ( 0 ),

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

      iExplicitlyMuted( EFalse ),

      iBackground( ETrue )

    {

    iMceManagerUid.iUid = KMusUiUid;

    iBackground = IsBackgroundStartup();

    }

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

//

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

//

void CMusEngMceSession::ConstructL()

    {

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

    iTelephoneUtils = CMusEngTelephoneUtils::NewL( *this );

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

    iManager = CMceManager::NewL( iMceManagerUid,

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

    iRemoteDetails = HBufC::NewL( RProperty::KMaxPropertySize );

    iRemoteDetails->Des().Copy( KNullDesC );

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

    }

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

//

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

//

CMusEngMceSession::~CMusEngMceSession()

    {

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

    delete iSipProfileHandler;

    delete iSession;

    delete iManager;

    delete iUpdateTimer;

    delete iTelephoneUtils;

    delete iRemoteDetails;

    RProperty::Set( NMusSessionApi::KCategoryUid, 

                    NMusSessionApi::KFastMode, 

                    MusSettingsKeys::EFastModeDisabled );

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

    }

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

// From MMusEngDisplayHandler

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

//

TRect CMusEngMceSession::Rect() const

    {

    MUS_LOG( "mus: [ENGINE]  CMusEngMceSession::Rect()" )

    return iRect;

    }

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

// From MMusEngDisplayHandler

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

//

void CMusEngMceSession::SetRectL( const TRect& aRect )

    {

    MUS_LOG( "mus: [ENGINE]  CMusEngSession::SetRectL()" )

    iRect = aRect;

    RectChangedL();

    }

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

// From MMusEngDisplayHandler

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

//

void CMusEngMceSession::SetSecondaryRectL( const TRect& aSecondaryRect )

    {

    MUS_LOG( "mus: [ENGINE]  CMusEngMceSession::SetSecondaryRectL()" )

    // Same rect is set by primary and secondary setters

    iRect = aSecondaryRect;

    RectChangedL();

    }

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

// From MMusEngDisplayHandler

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

//

TRect CMusEngMceSession::SecondaryRect() const

    {

    MUS_LOG( "mus: [ENGINE]  CMusEngMceSession::SecondaryRect()" )

    return iRect;

    }

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

// From MMusEngDisplayHandler

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

//

MMusEngDisplayHandler::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;

    }

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

//

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

//        

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

    }

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

// 

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

//

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

    }

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

// 

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

//

TBool CMusEngMceSession::IsDisplayEnabled()

    {

    TBool enabled( EFalse );

    if ( iSession )

        {

        CMceDisplaySink* display = 

           MusEngMceUtils::GetDisplay( *iSession, ETrue );

        if ( display )

           {

           enabled = display->IsEnabled();

           }

        }

    return enabled;

    }

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

// From MMusEngDisplayHandler

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

//

TBool CMusEngMceSession::IsDisplayActive()

    {

    return ( IsDisplayEnabled() );

    }

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

// From MMusEngAudioRoutingObserver

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

//

void CMusEngMceSession::AudioRoutingChanged()

    {

    InformObserverAboutPlayerUpdate( LocalVideoPlayer() );

    InformObserverAboutPlayerUpdate( RemoteVideoPlayer() );

    }

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

// From MLcSession 

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

//

MLcSession::TLcSessionState CMusEngMceSession::LcSessionState() const

    {

    TLcSessionState lcSessionState = MLcSession::EUninitialized;

    if ( iSession )

        {

        switch( iSession->State() )

            {

            case CMceSession::EIdle: 

                {

                lcSessionState = MLcSession::EInitialized;

                break;

                }

            case CMceSession::EIncoming:

            case CMceSession::EProceeding:

            case CMceSession::EReserving:

                {

                lcSessionState = MLcSession::EReceived;

                break;

                }

            case CMceSession::EOffering:

            case CMceSession::EAnswering:

                {

                lcSessionState = MLcSession::EOpening;

                break;

                }

            case CMceSession::EEstablished:

                {

                lcSessionState = MLcSession::EOpen;

                break;

                }

            case CMceSession::ECancelling:

            case CMceSession::ETerminating:

                {

                lcSessionState = MLcSession::EClosing;

                break;

                }

            case CMceSession::ETerminated:

                {

                lcSessionState = MLcSession::EClosed;

                break;

                }

            default:

               {

               lcSessionState = MLcSession::EUninitialized;

               break;

               }

            }

        }

    return  lcSessionState;

    }

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

// From MLcSession

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

//

void CMusEngMceSession::SetLcSessionObserver( MLcSessionObserver* aObserver )

    {

    iLcSessionObserver = aObserver;

    }

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

// From MLcSession

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

//

void CMusEngMceSession::SetLcUiProvider( MLcUiProvider* aUiProvider )

    {

    iLcUiProvider = aUiProvider;

    }

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

// From MLcSession

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

//

MLcVideoPlayer* CMusEngMceSession::RemoteVideoPlayer()

    {

    return NULL;

    }

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

// From MLcSession

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

//

MLcVideoPlayer* CMusEngMceSession::LocalVideoPlayer()

    {

    return NULL;

    }

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

// From MLcSession

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

//

const TDesC& CMusEngMceSession::LocalDisplayName()

    {

    return KNullDesC;

    }

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

// From MLcSession

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

//

const TDesC& CMusEngMceSession::RemoteDisplayName()

    {

    return KNullDesC;

    }

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

// From MLcSession

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

//

TInt CMusEngMceSession::SetParameter( TInt /*aId*/, TInt /*aValue*/ )

    {

    return KErrNotSupported;

    }

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

// From MLcSession

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

//

TInt CMusEngMceSession::ParameterValue( TInt /*aId*/ )

    {

    return KErrNotSupported;

    }

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

// From MLcSession

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

//

TBool CMusEngMceSession::IsBackgroundStartup()

    {

    TInt fastMode;

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

                                 NMusSessionApi::KFastMode, 

                                 fastMode );

    return ( error == KErrNone && 

             iBackground &&

             fastMode == MusSettingsKeys::EFastModeOn );

    }

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

// From MLcSession

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

//

TInt CMusEngMceSession::SetForegroundStatus( TBool aIsForeground )

    {

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

              aIsForeground )

    if ( aIsForeground )

        {

        // Only clear the bg info, do not ever enable it again

        iBackground = EFalse;

        }

    return KErrNone;

    }

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

// From MLcSession

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

//   

const TDesC& CMusEngMceSession::RemoteDetails()

    {

    // Don't care about error, empty value will be used in that case

    TPtr ptrDetails( iRemoteDetails->Des() );

    RProperty::Get( NMusSessionApi::KCategoryUid,

                    NMusSessionApi::KTelNumber,

                    ptrDetails ); 

    return *iRemoteDetails;

    }

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

// From MLcSession

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

//