/*

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

*

*/

#include <sip.h>

#include <MceManager.h>

#include <MceFCMsgExchange.h>

#include <Mcedefs.h>

#include <commdbconnpref.h>

#include <f32file.h>

#include <BADESCA.H>

#include "CMCETestUIEngine.h"

#include "CMCETestUIEngineMultimediaObserver.h"

#include "CMCETestUIEngineProfileContainer.h"

#include "CMCETestUIEngineProfile.h"

#include "CMCETestUIEngineRefer.h"

#include "CMCETestUIEngineOutSession.h"

#include "CMCETestUIEngineSipObserver.h"

#include "MMCETestUIUserInterface.h"

#include "CMCETestUIQuestionSingleSelection.h"

#include "CMCETestUIEngineOutEvent.h"

#include "CMCETestUIEngineOutRefer.h"

#include "CMCETestUIEngineCodec.h"

#include "CMCETestUIEngineVideoCodec.h"

#include "CMCETestUIEngineAudioStream.h"

#include "CMCETestUIEngineVideoStream.h"

#include "CMCETestUIEngineVideoSink.h"

#include "CMCETestUIEngineVideoSource.h"

#include "TMCETestUIEngineCmdUpdateSession.h"

#include "TMCETestUIEngineCmdAcceptSession.h"

#include "CMCETestUIEngineInSession.h"

#include "MCETestUIDebug.h"

#include "CMCETestUIEngineRefer.h"

#include "CMCETestUIEngineOutSession.h"

#include "CMCETestUIEngineInSession.h"

#include "CMCETestUIEngineOutEvent.h"

#include "CMCETestUIEngineInEvent.h"

#include "CMCETestUIEngineOutRefer.h"

#include "CMCETestUIEngineInRefer.h"

// MCE Interface

#include <MceOutSession.h>

#include <MceInSession.h>

#include <MceAudioStream.h>

#include <MceVideoStream.h>

#include <MceOutEvent.h>

#include <MceOutRefer.h>

#include <MceAudioCodec.h>

#include <MCEDisplaySink.h>

#include <MCECameraSource.h>

#include <MCERtpSource.h>

#include <MCEAudioCodec.h>

#include <MCEVideoCodec.h>

#include <MCEAMRCodec.h>

#include <MCEMicSource.h>

#include <MCERtpSink.h>

#include <MCERtpSource.h>

#include <MCESpeakerSink.h>

#include <MCEStreamBundle.h>

#include <mcedefs.h>

#include <mcerefer.h>

// Applicaple commands

#include "TMCETestUIEngineCmdBase.h"

#include "TMCETestUIEngineCmdCreateSession.h"

#include "TMCETestUIEngineCmdSelectProfile.h"

#include "TMCETestUIEngineCmdCreateEvent.h"

// PoC priority

const TUint KAudioPriorityPocAudioUplink                  = 95;

const TUint KAudioPriorityPocAudioDownlink                = 95;

const TUint KAudioPrefPocAudioUplink                      = 0x05130001;

const TUint KAudioPrefPocAudioDownlink                    = 0x05120001;

// VoIP priority

const TUint KSVPAudioPriorityAudioUplink                  = 100;

const TUint KSVPAudioPriorityAudioDownlink                = 100;

const TUint KSVPAudioPrefAudioUplink                      = 0x05220001; 

const TUint KSVPAudioPrefAudioDownlink                    = 0x05210001; 

//SWIS Playback

const TUint KAudioPrioritySwisPlayback                    = 74;

const TUint KAudioPrefSwisPlayback                        = 0x05330001;

const TUint KJitterBufferInactTimeout 					  = 10000;

const TUint KJitterBufferSize							  = 200;

const TUint KJitterBufferTreshold						  = 100;

const TUint KJitterBufferTresholdRealTimeVideoVideo	      = 20;

const TUint KJitterBufferTresholdRealTimeVideoAudio	      = 2;

const TUint KJitterBufferSizeRealTimeVideoAudio	          = 30;

//const TUint KJitterBufferSize							  = 1000;

//const TUint KJitterBufferTreshold						  = 500;

//const TUint KAudioPrefAudioUplink                      = 0x05220001;

//const TUint KAudioPrefAudioDownlink                    = 0x05210001;

// DTMF

const TUint KDtmfAudioPriority                           = 45;

const TUint KDtmfAudioPref                               = 0x00150001; 

#define IS_DOWNLINK( a ) ( a->Source()->Type() == KMceRTPSource )

// CONSTANTS

// Experimental Uid for UI engine, reserve own if needed

const TUid KUIEngineUid = { 0x10281F9B };  

const TUid KUIOptionsUid = { 0x10123F9E };

_LIT8( KFCTypeTBCP, "TBCP" ); 

_LIT8( KMCERtpSinkIdentity, "RtpSink@multimedia.engine.com" ); 

_LIT8( KMCERtpSourceIdentity, "RtpSource@multimedia.engine.com" ); 

// ============================ MEMBER FUNCTIONS ===============================

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

// CMCETestUIEngine::NewL

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

//

EXPORT_C CMCETestUIEngine* CMCETestUIEngine::NewL() 

    {

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

    CleanupStack::PushL( self );

    self->ConstructL( );

    CleanupStack::Pop( self );

    return self;  

    }

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

// CMCETestUIEngine::CMCETestUIEngine

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

//

CMCETestUIEngine::CMCETestUIEngine()

    : iNextOutSessionId( 0 ),iNextInSessionId( 0 ),

      iNextOutEventId(0),iNextInEventId(0),

      iNextOutReferId(0),iNextInReferId(0),

      iFCSession(EFalse), iRtcpFlag(EFalse),iKoppaFlag(ETrue), 

      iBundle(EFalse), iSdp(EFalse),i180PreCondition(EFalse),iSecureSessionAVP(EFalse),

	  iSecPreconditions(EFalse),iAutoResponse(EFalse),

      iVoIPFlag(EFalse), iHoldWithAddress( ETrue ),iPriorityType( KVoIPPriority ),

      iJitterBufTreshold( KJitterBufferTreshold ), iJitterBufSize( KJitterBufferSize ),

      iJitterBufTimeout(KJitterBufferInactTimeout), iMultiCodecSupport(ETrue)

     {

     }

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

// CMCETestUIEngine::ConstructL

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

//

void CMCETestUIEngine::ConstructL()

    {

    iSipObserver = CMCETestUIEngineSipObserver::NewL();

  //  iSip = CSIP::NewL( KUIEngineUid, *iSipObserver );

  //	  iSip = CSIP::NewL( KUIOptionsUid, *iSipObserver );

	iSip = iSipObserver->GetSipInstance();

    iProfiles = CMCETestUIEngineProfileContainer::NewL( *this, *iSip );

    iManager = CMceManager::NewL( KUIEngineUid, &iDataContainer );

    iMMObserver = CMCETestUIEngineMultimediaObserver::NewL( *this );

	iManager->SetSessionObserver( iMMObserver );

	iManager->SetTransactionObserver( iMMObserver ); 

	iManager->SetInTransactionObserver( iMMObserver ); 

	iManager->SetInSessionObserver( iMMObserver );

	iManager->SetMediaObserver( iMMObserver );

	iManager->SetRtpObserver( iMMObserver );	

	iManager->SetEventObserver( iMMObserver );	

	iManager->SetInEventObserver( iMMObserver );

	iManager->SetReferObserver(iMMObserver);

	iManager->SetInReferObserver(iMMObserver);

	iManager->SetDtmfObserver( iMMObserver );

	iCallWatcher = CMCEPoCOmaCSCallWatcher::NewL( iMMObserver );

	iCallWatcher->Subscribe();	

    iFC = CMceFcMsgExchange::NewL( *iManager, KFCTypeTBCP );

    iOutSessionWithProfile = EFalse;        

    iOutSessionWithAPList = EFalse;

    iOutSessionWithAPNumber = EFalse;

    }

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

// CMCETestUIEngine::~CMCETestUIEngine

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

//

EXPORT_C CMCETestUIEngine::~CMCETestUIEngine()

    {

    iCommands.ResetAndDestroy();

    iOutSessions.ResetAndDestroy();

    iInSessions.ResetAndDestroy();

    iOutEvents.ResetAndDestroy();

    iInEvents.ResetAndDestroy();

    iOutRefers.ResetAndDestroy();

    iInRefers.ResetAndDestroy();

    iTransactionIds.Close();

    delete iCallWatcher;

    delete iFC;

    delete iManager;

    delete iMMObserver;

    delete iProfiles;

    delete iSip;

    delete iSipObserver;

    }

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

// CMCETestUIEngine::GetCommandsL

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

//

EXPORT_C const RPointerArray<TMCETestUIEngineCmdBase>& 

        CMCETestUIEngine::GetCommandsL()

    {

    iCommands.ResetAndDestroy();

    iCommands.Append( new (ELeave) TMCETestUIEngineCmdSelectProfile( *this ) );

    TBool canCreateOutSession = EFalse;

    const RPointerArray<CMCETestUIEngineProfile> profiles = UsedProfiles();

    // OutSession can be created with profile

    for ( TInt i = 0; i < profiles.Count(); ++i )

        {

        if ( profiles[i]->IsRegistered() )

            {

            canCreateOutSession = ETrue;

            }

        }

      // TODO: OutSession can be created also with event or refer.

    //       Add check for those.    

    // Provide caller with ability to create an outsession.

    if ( canCreateOutSession )

        {    

     iCommands.Append( 

                    new (ELeave) TMCETestUIEngineCmdCreateSession( *this ) );

        }

    iCommands.Append( 

                    new (ELeave) TMCETestUIEngineCmdCreateSessionUsingAPList( *this ) );

    iCommands.Append( 

                    new (ELeave) TMCETestUIEngineCmdCreateSessionUsingAPNumber( *this ) );

    if ( canCreateOutSession )

        {    

        iCommands.Append( 

                    new (ELeave) TMCETestUIEngineCmdCreateEvent( *this ) );

        iCommands.Append( 

                    new (ELeave) TMCETestUIEngineCmdCreateRefer( *this ) );

        }

    return iCommands;    

    }

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

// CMCETestUIEngine::SetUserInterface

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

//

EXPORT_C void CMCETestUIEngine::SetUserInterface(

        MMCETestUIUserInterface* aUserInterface )

    {

    iUserInterface = aUserInterface;

    }

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

// CMCETestUIEngine::AvailableProfiles

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

//

EXPORT_C const RPointerArray<CMCETestUIEngineProfile>& 

        CMCETestUIEngine::AvailableProfiles( )

    {

    return iProfiles->AvailableProfiles();

    }

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

// CMCETestUIEngine::UsedProfiles

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

//

EXPORT_C const RPointerArray<CMCETestUIEngineProfile>& 

        CMCETestUIEngine::UsedProfiles( )

    {

    return iProfiles->UsedProfiles();

    }

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

// CMCETestUIEngine::DeleteSession

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

//

EXPORT_C void CMCETestUIEngine::DeleteSession( 

        CMCETestUIEngineSession& aSession )

    {

    for ( TInt i = 0; i < iOutSessions.Count(); ++i )

        {

        if ( iOutSessions[i] == &aSession )

            {

            delete iOutSessions[i];

            iOutSessions.Remove( i );

            iOutSessions.Compress();

            EngineStateChangedL();

            return;

            }

        }

    for ( TInt i = 0; i < iInSessions.Count(); ++i )

        {

        if ( iInSessions[i] == &aSession )

            {

         	delete iInSessions[i];

            iInSessions.Remove( i );

            iInSessions.Compress();

            EngineStateChangedL();

            return;

            }

        }

    }

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

// CMCETestUIEngine::CreateOutSession

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

//

EXPORT_C CMCETestUIEngineOutSession& CMCETestUIEngine::CreateOutSessionL( 

        CMCETestUIEngineProfile& aProfile,

        TDirection aDirection ,

        TVideoDirection aVideoDirection ,

        TSessionType aSessionType)

    {

    SetPriorities();

    CMCETestUIEngineOutSession* outSession = CMCETestUIEngineOutSession::NewL( 

            *this, aProfile, aDirection,aVideoDirection,aSessionType );

    CleanupStack::PushL ( outSession );

    iOutSessions.Append( outSession );

	NotifyUser( KUserNotificationSessionCreated );

	EngineStateChangedL();	    

    CleanupStack::Pop( outSession );

    return *outSession;

    }

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

// CMCETestUIEngine::CreateOutSession

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

//

EXPORT_C CMCETestUIEngineOutSession& CMCETestUIEngine::CreateOutSessionL( 

        TUint32 aIAPId,

        TDirection aDirection ,

        TVideoDirection aVideoDirection ,

        TSessionType aSessionType)

    {

    SetPriorities();

    CMCETestUIEngineOutSession* outSession = CMCETestUIEngineOutSession::NewL( 

            *this, aIAPId, aDirection,aVideoDirection,aSessionType );

    CleanupStack::PushL ( outSession );

    iOutSessions.Append( outSession );

	NotifyUser( KUserNotificationSessionCreated );

	EngineStateChangedL();	    

    CleanupStack::Pop( outSession );

    return *outSession;

    }

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

// CMCETestUIEngine::CreateOutSession

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

//

EXPORT_C CMCETestUIEngineOutSession& CMCETestUIEngine::CreateOutSessionL( CMceRefer& aRefer)

    {

    SetPriorities();

    TSessionType sessionType = ECustomSession;	

	TDirection direction = ENotSpesified;

	TVideoDirection videoDirection = EVideoNotSpesified;

    CMCETestUIEngineOutSession* outSession = CMCETestUIEngineOutSession::NewL( 

            *this, aRefer ,direction,videoDirection,sessionType);

    CleanupStack::PushL ( outSession );

    iOutSessions.Append( outSession );

	NotifyUser( KUserNotificationSessionCreated );

	EngineStateChangedL();	    

    CleanupStack::Pop( outSession );

    return *outSession;

    }

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

// CMCETestUIEngine::CreateInSession

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

//

EXPORT_C CMCETestUIEngineInSession& CMCETestUIEngine::CreateInSessionL(

        CMceInSession* aSession )

    {

    if ( aSession->Streams().Count()  == 0)

    	{

    	AddSendRecvDefaultAudioStreamsL(aSession);

    	}

    UpdateWithPriorityCodecValues(aSession);

    if( i180PreCondition )

    	{

    	aSession->SetModifierL( KMce100Rel, KMce100RelRequired );

    	}

   	if( iHoldWithAddress )

    	{

    	aSession->SetModifierL( KMceMediaDirection, KMceMediaDirectionWithAddress );

    	} 

    if (iSecureSessionAVP )

		{

		aSession->SetModifierL( KMceSecureSession, KMceSecurePlainAVP );

		} 	

    if(IsFCSession())

    	{

    	UpdatePoCValues( aSession );

    	}

    else 

    	{

    	UpdateInactivitytimeValues(aSession);

    	}

    if( iBundle )

        {

        BundleStreamsL( aSession );

        }

    UpdateRtpSink(aSession);

    CMCETestUIEngineInSession* inSession = CMCETestUIEngineInSession::NewL(

            *this, aSession );

    CleanupStack::PushL( inSession );

    iInSessions.Append( inSession );

	NotifyUser( KMiscIncomingSession );

	EngineStateChangedL();	

	CleanupStack::Pop( inSession );

	return *inSession;   

    }

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

// CMCETestUIEngine::AddSendRecvDefaultAudioStreamsL

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

//

void CMCETestUIEngine::AddSendRecvDefaultAudioStreamsL(CMceInSession* aSession)

	{

	//create stream, boundstream with micsource - rtpsink and rtpsource and speaker sink

	    CMceAudioStream* audioOutStream = NULL;

	    CMceAudioStream* audioOutStreamLocal = NULL;

	    // Create outstream (== uplink)

       audioOutStream = CMceAudioStream::NewLC();

	   CMceMicSource* mic = NULL;

	   mic = CMceMicSource::NewLC();

	   audioOutStream->SetSourceL( mic );	

	   CleanupStack::Pop( mic );

	   CMceRtpSink* rtpSink;

	   if(iRtcpFlag)

			{

			rtpSink = CMceRtpSink::NewL(ETrue);	

			CleanupStack::PushL(rtpSink);

			}

		else

			{

			rtpSink = CMceRtpSink::NewLC();	

			}

		audioOutStream->AddSinkL( rtpSink );

		CleanupStack::Pop( rtpSink );

	    // Create instream (== downlink)

	    CMceAudioStream* audioInStream = NULL;

	    audioInStream = CMceAudioStream::NewLC();

		CMceRtpSource* rtpSource = CMceRtpSource::NewLC( iJitterBufSize, 

                                	                         iJitterBufTreshold, 

                                	                         iJitterBufTimeout, 0);

		audioInStream->SetSourceL( rtpSource );

		CleanupStack::Pop( rtpSource );

		CMceSpeakerSink* speaker = CMceSpeakerSink::NewLC();

		audioInStream->AddSinkL( speaker );

		CleanupStack::Pop( speaker );

		audioOutStream->BindL( audioInStream ); 

	    CleanupStack::Pop( audioInStream );     

	   // Add streams to OutSession    

	    aSession->AddStreamL( audioOutStream );

	    CleanupStack::Pop( audioOutStream );

 	}

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

// CMCETestUIEngine::UpdateIncomingSessionVoIPData

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

//

void CMCETestUIEngine::UpdateIncomingSessionVoIPDataL(CMceInSession* aSession)

	{

	// modify codecs and codec settings if streams found

    if ( aSession->Streams().Count() )

        {

       	const RPointerArray< CMceMediaStream >& streams = aSession->Streams();

       for ( TInt i = 0; i < streams.Count(); i++ )

            {

            CMceMediaStream* stream1 = ( CMceMediaStream* ) streams[i];