/*

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

*

*/

#include <mcedefs.h>

#include "CMCETestUIEngineMultimediaObserver.h"

#include "TMCETestUIEngineCmdAcceptSession.h"

#include "CMCETestUIEngineSession.h"

#include "CMCETestUIEngineInSession.h"

#include "CMCETestUIEngine.h"

#include "CMCETestUIEngineInSession.h"

#include "CMCETestUIEngineOutSession.h"

#include "CMCETestUIEngineSession.h"

#include "CMCETestUIEngineAudioStream.h"

#include "MCETestUIEngineConstants.h"

#include "TMCETestUIEngineCmdAnswerSession.h"

#include "mcetransactiondatacontainer.h"

#include <MCEInSession.h>

#include <MCEAudioStream.h>

#include <MCESpeakerSink.h>

#include <MCERtpSource.h>

#include <MCEMicSource.h>

#include <MCEFileSource.h>

#include <MCEMediaSource.h>

#include <e32err.h>

#include <e32debug.h>

#include "MCETestUIDebug.h"	

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

// CMCETestUIEngineMultimediaObserver::NewL

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

//

CMCETestUIEngineMultimediaObserver* CMCETestUIEngineMultimediaObserver::NewL( 

			CMCETestUIEngine& aEngine )

	{

	CMCETestUIEngineMultimediaObserver* self = 

			new (ELeave) CMCETestUIEngineMultimediaObserver( aEngine );

	CleanupStack::PushL( self );

	self->ConstructL();

	CleanupStack::Pop( self );

	return self;

	}

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

// CMCETestUIEngineMultimediaObserver::CMCETestUIEngineMultimediaObserver

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

//

CMCETestUIEngineMultimediaObserver::CMCETestUIEngineMultimediaObserver(

			CMCETestUIEngine& aEngine):

	iEngine( aEngine )

	{

	}

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

// CMCETestUIEngineMultimediaObserver::ConstructL

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

//

void CMCETestUIEngineMultimediaObserver::ConstructL()

	{

	}

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

// CMCETestUIEngineMultimediaObserver::~CMCETestUIEngineMultimediaObserver

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

//

CMCETestUIEngineMultimediaObserver::~CMCETestUIEngineMultimediaObserver()

	{

	}

// -- From MMCEInSessionObserver--------------------------------------------------

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

// CMCETestUIEngineMultimediaObserver::IncomingSession

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

//

void CMCETestUIEngineMultimediaObserver::IncomingSession(

			CMceInSession* aSession,

            TMceTransactionDataContainer* /*aContainer*/ )

	{

	if(iEngine.iAutoResponse)

		{

		TInt state = aSession->State();

		switch( state ) 

			{

			case CMceSession::EIncoming: 

			    {

			    aSession->UpdateL();

				break;

			    }

			default: 

			    {    

			    break;

			    }

			}  

		}

	else if(iEngine.iVoIPFlag)	

		{

		TInt state = aSession->State();

		switch( state ) 

			{

			case CMceSession::EIncoming: 

			    {

			    iEngine.NotifyUser( KMiscIncomingVoIPSession );

			    iEngine.UpdateIncomingSessionVoIPDataL(aSession);

			  	break;

			    }

			default: 

			    {    

			    break;

			    }

			}  

		}

	else

		{

		CMCETestUIEngineInSession& engineSession = 

	    iEngine.CreateInSessionL( aSession ); 

		}

	}

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

// CMCETestUIEngineMultimediaObserver::IncomingUpdate

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

//

void CMCETestUIEngineMultimediaObserver::IncomingUpdate(

					CMceSession& aOrigSession, 

					CMceInSession* aUpdatedSession,

    				TMceTransactionDataContainer* /*aContainer*/ )

	{

//	CMCETestUIEngineInSession& engineSession = 

//	    iEngine.CreateInSessionL( aUpdatedSession); 

	iEngine.IncomingUpdateL( aOrigSession, aUpdatedSession )	;

	}

// -- From MMCESessionObserver -------------------------------------------------

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

// CMCETestUIEngineMultimediaObserver::SessionStateChanged

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

//	

void CMCETestUIEngineMultimediaObserver::SessionStateChanged(

            CMceSession& aSession,

            TMceTransactionDataContainer* aContainer )

	{

	if(iEngine.iAutoResponse)

		{

		TInt state = aSession.State();

		switch( state ) 

			{

			case CMceSession::EProceeding: 

			    {

			    CMceInSession& inSession = 

                                    static_cast<CMceInSession&>(aSession);

                inSession.AcceptL();

			    break;

			    }

			default: 

			    {    

			    break;

			    }

			}  

		}

	else if(iEngine.iVoIPFlag)

		{

		TInt state = aSession.State();

    	switch( state ) 

			{

			case CMceSession::EProceeding: 

			    {

			    CMceInSession& inSession = 

                                    static_cast<CMceInSession&>(aSession);

                inSession.RingL();

                inSession.AcceptL();

                iEngine.UpdateIncomingSessionVoIPDataAfterAnswerL(inSession);             

			    break;

			    }

			case CMceSession::EEstablished: 

				{

				CMceInSession& inSession = 

                                    static_cast<CMceInSession&>(aSession);

//				iEngine.UpdateIncomingSessionVoIPDataAfterAnswerL(inSession);

                CMCETestUIEngineInSession* session = CMCETestUIEngineInSession::NewL(

			                                                           iEngine, &inSession );

			    CleanupStack::PushL( session );

			    iEngine.iInSessions.Append( session );

				iEngine.EngineStateChangedL();	

				CleanupStack::Pop( session );

				}

			default: 

			    {    

			    break;

			    }

			}  

		}

    if( CMceSession::EEstablished == aSession.State() )

        {

        const RPointerArray<CMCETestUIEngineOutSession>& outsessions = 

                                                        iEngine.OutSessions();     

        const RPointerArray<CMCETestUIEngineInSession>& insessions = 

                                                        iEngine.InSessions();

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

            {

            if ( &outsessions[i]->Session() == &aSession && outsessions[i]->iHoldInProgress  )

                {

                outsessions[i]->EnableAudioL();

                outsessions[i]->iHoldInProgress = EFalse;

                }

            }

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

            {

            if ( &insessions[i]->Session() == &aSession && insessions[i]->iHoldInProgress )

                {

                insessions[i]->EnableAudioL();

                insessions[i]->iHoldInProgress = EFalse;

                }

            }

        }

	HBufC8* hbuf = aContainer->GetReasonPhrase();

	if(hbuf)

		{

		HBufC* buf = HBufC::NewL(hbuf->Length());

		TPtr ptr = buf->Des();

		ptr.Copy(*hbuf);

		TBuf16<100> buf16;

		buf16.Append(KUserNotificationSessionStateChanged );

		buf16.Append(KSpace);

		TInt code = aContainer->GetStatusCode();

	    buf16.AppendNum(code);

	    buf16.Append(*buf);

	 	iEngine.NotifyUser(buf16);

	  	delete buf;

		}

	else

		{

		iEngine.NotifyUser( KUserNotificationSessionStateChanged );	

		}	

	delete hbuf;

	iEngine.EngineStateChangedL();	

	}

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

// CMCETestUIEngineMultimediaObserver::SessionConnectionStateChanged

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

//		

void CMCETestUIEngineMultimediaObserver::SessionConnectionStateChanged(

            CMceSession& /*aSession*/,

            TBool /*aActive*/) 

	{

	}

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

// CMCETestUIEngineMultimediaObserver::Failed

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

//                    

void CMCETestUIEngineMultimediaObserver::Failed( CMceSession& /*aSession*/, 

                                                 TInt /*aError*/ )

	{	 

	iEngine.NotifyUser( KUserNotificationSessionFailed );

	iEngine.EngineStateChangedL();

    }

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

// CMCETestUIEngineMultimediaObserver::UpdateFailed

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

//

void CMCETestUIEngineMultimediaObserver::UpdateFailed( 

            CMceSession& /*aSession*/, 

            TMceTransactionDataContainer* /*aContainer*/ )

	{

	iEngine.NotifyUser( KUpdateFailed );

	iEngine.EngineStateChangedL();	        

    }

// From MMCETransactionObserver -------------------------------------------------

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

// CMCETestUIEngineMultimediaObserver::TransactionResponse

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

void CMCETestUIEngineMultimediaObserver::TransactionResponse(

						    			CMceSession& /*aSession*/,

						    			TMceTransactionId aTransactionId,

						    			TMceTransactionDataContainer* aContainer )

	{

	MCE_TESTUI_DEBUG1("CMCETestUIEngineMultimediaObserver::TransactionResponse entry")

	iEngine.NotifyUser( KResponseReceived );

	iEngine.EngineStateChangedL();	        

	//Clean the Container

	LogContainer( aContainer, aTransactionId );

	MCE_TESTUI_DEBUG1("CMCETestUIEngineMultimediaObserver::TransactionResponse exit") 

	}

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

// CMCETestUIEngineMultimediaObserver::TransactionFailed

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

void CMCETestUIEngineMultimediaObserver::TransactionFailed( 

					                    CMceSession& /*aSession*/,

						    			TMceTransactionId aTransactionId, 

						    			TInt aError )

 	{

 	MCE_TESTUI_DEBUG1("CMCETestUIEngineMultimediaObserver::TransactionFailed entry")

 	iEngine.RemoveTransactionId( aTransactionId );

 	iEngine.NotifyUser( KTransactionFailed );

 	iEngine.EngineStateChangedL();

	MCE_TESTUI_DEBUG3("CMCETestUIEngineMultimediaObserver::TransactionFailed aTransactionId", aTransactionId )

	MCE_TESTUI_DEBUG3("CMCETestUIEngineMultimediaObserver::TransactionFailed aError", aError )

 	MCE_TESTUI_DEBUG1("CMCETestUIEngineMultimediaObserver::TransactionFailed exit")

	}

// From MMCEInTransactionObserver -------------------------------------------------

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

// CMCETestUIEngineMultimediaObserver::TransactionResponse

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

void CMCETestUIEngineMultimediaObserver::IncomingRequest(

						    			const TDesC8& /*aMethod*/,

										CMceSession& /*aSession*/,

	    								TMceTransactionId aTransactionId,

	    								TMceTransactionDataContainer* aContainer )

	{

 	MCE_TESTUI_DEBUG1("CMCETestUIEngineMultimediaObserver::IncomingRequest entry")

	TUint code = 200;

	_LIT8( KMceSipOK,"OK");

	iEngine.AddTransactionIdL( aTransactionId );

	iEngine.NotifyUser( KRequestReceived );

	iEngine.EngineStateChangedL();	  

	LogContainer( aContainer, aTransactionId );

	}

// -- from MMCEStreamObserver --------------------------------------------------

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

// CMCETestUIEngineMultimediaObserver::StreamStateChanged

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

//

void CMCETestUIEngineMultimediaObserver::StreamStateChanged( 

            CMceMediaStream& aStream )

	{	

    iEngine.NotifyStreamStateChangeL( aStream );

	}

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

// CMCETestUIEngineMultimediaObserver::StreamStateChanged

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

//	

void CMCETestUIEngineMultimediaObserver::StreamStateChanged( 

			CMceMediaStream& aStream, 

			CMceMediaSink& /*aSink*/ )

    {

    iEngine.NotifyStreamStateChangeL( aStream );

	}

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

// CMCETestUIEngineMultimediaObserver::StreamStateChanged

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

//	

void CMCETestUIEngineMultimediaObserver::StreamStateChanged( 

			CMceMediaStream& aStream, 

			CMceMediaSource& aSource)

	{

	TInt state = aStream.State();

	TBuf16<100> buf16;

//	buf16.Append(KUserNotificationStreamStateChanged );

//	buf16.Append(KLeftParenthesis);

	TInt transProgress;

	switch( state ) 

		{

		case CMceMediaStream::ETranscodingRequired: 

		    buf16.Append(KStreamTranscodingRequired); 

		    iEngine.NotifyUser(buf16);

		    break;

		case CMceMediaStream::ETranscoding: 

			{

			buf16.Append(KStreamTranscoding);

			CMceFileSource& fileSource = static_cast<CMceFileSource&>(aSource);

			transProgress = fileSource.TranscodingProgressL();

			buf16.Append(KLeftParenthesis);

			buf16.AppendNum(transProgress);

			buf16.Append(KRightParenthesis);

			}

		    break;

		default: 

		    buf16.Append(KSessionStateUnknown); 

		}

	if( transProgress == 10 || transProgress == 100 )

		{

		iEngine.NotifyUser(buf16);

		}

	}

// -- from MMCERtpObserver -----------------------------------------------------

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

// CMCETestUIEngineMultimediaObserver::SRReceived

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

//

void CMCETestUIEngineMultimediaObserver::SRReceived( 

			CMceSession& /*aStream*/, 

			CMceMediaStream& /*aSource*/ )

	{

	RDebug::Print(_L("SR Received "));

	if(iEngine.iRtcpFlag)

		{

		iEngine.NotifyUser( KUserNotificationSRReceived );

		iEngine.EngineStateChangedL();

		}

	else

		{

		iEngine.iSRCount++;

		if(iEngine.iSRCount == 20)

			{

			iEngine.NotifyUser( KUserNotificationSRReceived );

			iEngine.EngineStateChangedL();

			iEngine.iSRCount = 0;

			}

		}

	}

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

// CMCETestUIEngineMultimediaObserver::RRReceived

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

//

void CMCETestUIEngineMultimediaObserver::RRReceived( 

			CMceSession&/* aStream*/,

			CMceMediaStream& /*aSource*/ )

	{

		RDebug::Print(_L("RR Received "));

		if(iEngine.iRtcpFlag)

			{

			iEngine.NotifyUser( KUserNotificationRRReceived );

			iEngine.EngineStateChangedL();

			}

		else

			{

			iEngine.iRRCount++;

			if(iEngine.iRRCount == 20)

				{

				iEngine.NotifyUser( KUserNotificationRRReceived );

				iEngine.EngineStateChangedL();

				iEngine.iRRCount = 0;

				}

			}

	}

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

// CMCETestUIEngineMultimediaObserver::InactivityTimeout

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

//		

void CMCETestUIEngineMultimediaObserver::InactivityTimeout( 

			CMceMediaStream& /*aStream*/,

			CMceRtpSource& /*aSource*/ )

	{

	iEngine.NotifyUser( KUserInactivityTimeoutReceived );

	iEngine.EngineStateChangedL();

	}

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

// CMCETestUIEngineMultimediaObserver::Activity

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

//		

void CMCETestUIEngineMultimediaObserver::Activity( 

			CMceMediaStream& /*aStream*/,

			CMceRtpSource& /*aSource*/ )

	{

	iEngine.NotifyUser( KUserActivityTimeReceived );

	iEngine.EngineStateChangedL();

	}