/*

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

#include "lcsessionobserver.h"

#include "musenglogger.h"

#include "lcuiprovider.h"

#include "lcvideoplayer.h"

#include "musengremotevideoplayer.h"

#include "musenglivevideoplayer.h"

#include "mccscreen.h"

// SYSTEM

#include <audiopreference.h>

#include <e32property.h>

#include <cntitem.h>

#include <cntfield.h>

#include <cntdef.h>

#include <cntfldst.h>

#include "svptimer.h"

RDrawableWindow* testWindow = 0;

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

//

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

//

CMusEngMceSession::CMusEngMceSession()

    {

    iBackground = IsBackgroundStartup();

    }

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

//

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

//

void CMusEngMceSession::ConstructL()

    {

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

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

    iLiveVideoPlayer = CMusEngLiveVideoPlayer::NewL( *this, iCameraHandler, *this );      

    iLcSessionState = MLcSession::EUninitialized;

    iTimer = CSVPTimer::NewL( *this, 1 ); 

    iCameraHandler.SetSession( this );

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

    }

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

//

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

//

CMusEngMceSession::~CMusEngMceSession()

    {

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

    delete iRemoteAddress;

    delete iRemoteVideoPlayer; 

    delete iLiveVideoPlayer;    

    delete iScreen;

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

    if ( !iScreen ){

        iScreen = CMccScreen::NewL(0,TPoint(0,0), TSize(640,640), 0, 1, 0, EFalse, testWindow);

        }

    iRect = aRect;

    if ( iScreen )

        {

        iScreen->SetPrimaryRectL(iRect);

        }

    }

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

// From MMusEngDisplayHandler

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

//

void CMusEngMceSession::SetSecondaryRectL( const TRect& aSecondaryRect )

    {

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

    if ( !iScreen ){

        iScreen = CMccScreen::NewL(0,TPoint(0,0), TSize(640,640), 0, 1, 0, EFalse, testWindow);

        }

    // Same rect is set by primary and secondary setters

    iSetLocalRect = aSecondaryRect;

    if ( iScreen )

        {

        iScreen->SetSecondaryRectL(iSetLocalRect);

        }

    }

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

// From MMusEngDisplayHandler

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

//

TRect CMusEngMceSession::SecondaryRect() const

    {

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

    return iSetLocalRect;

    }

#if 0

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

//

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

//

void CMusEngTwoWaySession::SetSecondaryRectL( const TRect& aSecondaryRect )

    {

    MUS_LOG( "mus: [ENGINE]  -> CMusEngTwoWaySession::SetSecondaryRectL()" )

    iLocalRect = aSecondaryRect;

    MUS_LOG( "mus: [ENGINE]  <- CMusEngTwoWaySession::SetSecondaryRectL()" )

    }

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

//

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

//

TRect CMusEngTwoWaySession::SecondaryRect() const

    {

    MUS_LOG( "mus: [ENGINE]  -> CMusEngTwoWaySession::SecondaryRect()" )

    MUS_LOG( "mus: [ENGINE]  <- CMusEngTwoWaySession::SecondaryRect()" )

    return iLocalRect;

    }

#endif

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

// From MMusEngDisplayHandler

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

//

MMusEngDisplayHandler::TDisplayOrientation CMusEngMceSession::OrientationL()

    {

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

    return MMusEngDisplayHandler::EPortrait;

    }

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

//

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

//        

void CMusEngMceSession::SetOrientationL( TDisplayOrientation aOrientation )

    {

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

              aOrientation )

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

    }

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

// 

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

//

void CMusEngMceSession::EnableDisplayL( TBool aEnable )

    {

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

              aEnable )

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

    }

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

// 

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

//

TBool CMusEngMceSession::IsDisplayEnabled()

    {

    TBool enabled( EFalse );

    return enabled;

    }

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

// From MMusEngDisplayHandler

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

//

TBool CMusEngMceSession::IsDisplayActive()

    {

    return ( IsDisplayEnabled() );

    }

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

// From MLcSession 

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

//

MLcSession::TLcSessionState CMusEngMceSession::LcSessionState() const

    {

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

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

    }

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

// From MLcSession

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

//

void CMusEngMceSession::SetLcSessionObserver( MLcSessionObserver* aObserver )

    {

    iLcSessionObserver = aObserver;

    }

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

// From MLcSession

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

//

void CMusEngMceSession::SetLcUiProvider( MLcUiProvider* aUiProvider )

    {

    iLcUiProvider = aUiProvider;

    }

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

// From MLcSession

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

//

MLcVideoPlayer* CMusEngMceSession::RemoteVideoPlayer()

    {

    return iRemoteVideoPlayer;

    }

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

// From MLcSession

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

//

MLcVideoPlayer* CMusEngMceSession::LocalVideoPlayer()

    {

    return iLiveVideoPlayer;

    }

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

// From MLcSession

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

//

const TDesC& CMusEngMceSession::LocalDisplayName()

    {

    return KNullDesC;

    }

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

// From MLcSession

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

//

const TDesC& CMusEngMceSession::RemoteDisplayName()

    {

    return *iRemoteAddress;

    }

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

// From MLcSession

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

//

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

    {

        if ( aId == 0 ){

            testWindow = reinterpret_cast<RDrawableWindow*>(aValue);

        }

    return KErrNotSupported;

    }

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

// From MLcSession

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

//

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

    {

    return KErrNotSupported;

    }

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

// From MLcSession

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

//

TBool CMusEngMceSession::IsBackgroundStartup()

    {    

    return ETrue;

    }

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

// From MLcSession

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

//

TBool CMusEngMceSession::SendDialTone( TChar aKey )

    {    

    MUS_LOG1( "mus: [ENGINE]  -> CMusEngMceSession::SendDialTone() key = %c",aKey )

    return ETrue;

    }

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

// From MLcAudioControl

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

//

TBool CMusEngMceSession::IsLcAudioMutedL()

    {    

    return EFalse;

    }

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

// From MLcAudioControl

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

//

void CMusEngMceSession::MuteLcAudioL( TBool aMute )

    {

    }

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

// From MLcAudioControl

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

//

TBool CMusEngMceSession::IsLcMicMutedL()

    {

    return EFalse;

    }

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

// From MLcAudioControl

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

//

void CMusEngMceSession::MuteLcMicL( TBool aMute )

    {

    }

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

// From MLcAudioControl

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

//

TBool CMusEngMceSession::IsEnablingLcLoudspeakerAllowed()

    {

    return ETrue;

    }

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

// From MLcAudioControl

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

//

void CMusEngMceSession::EnableLcLoudspeakerL( TBool aEnabled )

    {

    }

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

// From MLcAudioControl

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

//

TBool CMusEngMceSession::IsLcLoudspeakerEnabled()

    {

    return ETrue;

    }

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

// From MLcAudioControl

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

//

TInt CMusEngMceSession::LcVolumeL()

    {

    return 5;

    }

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

// From MLcAudioControl

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

//

void CMusEngMceSession::SetLcVolumeL( TInt aValue )

    {

    }

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

// From MLcAudioControl

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

//

void CMusEngMceSession::IncreaseLcVolumeL()

    {

    }

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

// From MLcAudioControl

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

//

void CMusEngMceSession::DecreaseLcVolumeL()

    {

    }

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

// From MLcAudioControl

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

//

void CMusEngMceSession::TimedOut( TInt aTimerId )

    {

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

/*

    iLcSessionState = MLcSession::EOpen;

    if ( iLcSessionObserver )

        {

    	MUS_LOG( "mus: [ENGINE]  -> CMusEngMceSession::TimedOut(), StateChanged" )

        iLcSessionObserver->StateChanged( *this );

        }

*/

        switch( aTimerId )

            {

            case 1: 

                {

    						MUS_LOG( "mus: [ENGINE]  -> CMusEngMceSession::TimedOut(), StateChanged -> Established" )

    					InformUiProviderAboutReceivingStart();

    					iLcSessionState = MLcSession::EOpen;

        				iLcSessionObserver->StateChanged( *this );

								// starting remote playing timer        				

        				iTimer->SetTime(10000, 3);

                break;

                }

            case 2: 

                {

    						MUS_LOG( "mus: [ENGINE]  -> CMusEngMceSession::TimedOut(), StateChanged -> RemotePlaying" )

    						iRemoteVideoPlayer->iState = MLcVideoPlayer::EPlaying;

        				iLcSessionObserver->StateChanged( *iRemoteVideoPlayer );

                break;

                }

            case 3: 

                {

    						MUS_LOG( "mus: [ENGINE]  -> CMusEngMceSession::TimedOut(), StateChanged -> LocalPlaying" )

    						iLiveVideoPlayer->iState = MLcVideoPlayer::EPlaying;

        				iLcSessionObserver->StateChanged( *iLiveVideoPlayer );

        				iTimer->SetTime(5000, 2);

                break;

                }

            case 10: 

                {

    						MUS_LOG( "mus: [ENGINE]  -> CMusEngMceSession::TimedOut(), Camera Toggle, StateChanged -> LocalPaused" )

    						iLiveVideoPlayer->iState = MLcVideoPlayer::EPaused;

        				iLcSessionObserver->StateChanged( *iLiveVideoPlayer );

        				iTimer->SetTime(10000, 11);

                break;

                }

            case 11: 

                {

    						MUS_LOG( "mus: [ENGINE]  -> CMusEngMceSession::TimedOut(), Camera Toggle, StateChanged -> LocalPlaying" )