/*

* Copyright (c) 2002-2004 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:    Controller

*

*/

// INCLUDE FILES

#include <mmf/common/mmfbase.h>

#include <ecam.h>

#include <mmf/server/sounddevice.h>

#include "mmccinterface.h"

#include "mmcccodecinformation.h"

#include "mcccontroller.h"

#include "mcccamerahandler.h"

#include "mcculdlclient.h"

#include "mccuids.hrh"

#include "mccresourcepool.h"

#include "mccresourceitem.h"

#include "mccqoscontroller.h"

#include "mcccontrollerlogs.h"

#include "mccasynclinkcreator.h"

#include "mmcccryptocontext.h"

#include "mccdatasink.h"

#include "mccdatasource.h"

#include "mccrtpdatasink.h"

const TInt KNumValue2 = 2;

_LIT( KMccControllerName, "mmcccontroller" );

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

// ============================= LOCAL FUNCTIONS ===============================

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

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

// CMccController::CMccController

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CMccController::CMccController()

    {

    }

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

// CMccController::~CMccController

// Destructor

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

//

CMccController::~CMccController()

    {

	__CONTROLLER( "CMccController::~CMccController" )

    CancelMmfMessage();

    // delete isessionarray

    iSessionArray.ResetAndDestroy();

    iSessionArray.Close();

    iCreatorArray.ResetAndDestroy();

    iCreatorArray.Close();

    // delete eventbuffer and contents of it

    iEventBuf.ResetAndDestroy();

    iEventBuf.Close();

    delete iQosController;

    delete iResourcePool;

    if ( iTranscoder )

        {

        iTranscoder->UnregisterEventObserver();

        /* Commented off since causes crash

        REComSession::DestroyedImplementation( iTranscoderKey );

        */

        delete iTranscoder;

        iTranscoder = NULL;   

        }

    iDtmfPayloadTypes.Close();

    #ifdef FTD_ENABLED

    iStreamStatsQueue.Close();

    iCodecStatsQueue.Close();

    iJBufferStatsQueue.Close();

    #endif

	__CONTROLLER( "CMccController::~CMccController, exit" )

    }

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

// CMccController::NewL

// Static constructor.

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

//

CMccController* CMccController::NewL()

    {

    CMccController* self = new ( ELeave ) CMccController;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CMccController::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CMccController::ConstructL()

    {

	__CONTROLLER( "CMccController::ConstructL" )

	User::LeaveIfError( User::RenameThread( KMccControllerName ) );

    CMMFAudioPlayDeviceCustomCommandParser* audPlayDevParser

        = CMMFAudioPlayDeviceCustomCommandParser::NewL( *this );

    CleanupStack::PushL( audPlayDevParser );

    AddCustomCommandParserL( *audPlayDevParser );

    CleanupStack::Pop( audPlayDevParser );

    CMMFAudioRecordDeviceCustomCommandParser* audRecDevParser

        = CMMFAudioRecordDeviceCustomCommandParser::NewL( *this );

    CleanupStack::PushL( audRecDevParser );

    AddCustomCommandParserL( *audRecDevParser );

    CleanupStack::Pop( audRecDevParser );

    iResourcePool = CMccResourcePool::NewL();

    iQosController = CMccQosController::NewL( *this, *iResourcePool );

    __CONTROLLER( "CMccController::ConstructL, creating devsound" )

    CMMFDevSound* devSound = CMMFDevSound::NewL();

    iMaxVolume = devSound->MaxVolume();

    __CONTROLLER_INT1( "CMccController::ConstructL, max vol:", iMaxVolume )

    iMaxGain = devSound->MaxGain();

    __CONTROLLER_INT1( "CMccController::ConstructL, max gain:", iMaxGain )

    delete devSound;

    iVolume = iMaxVolume / KNumValue2;

    iGain = iMaxGain / KNumValue2;

    #ifdef FTD_ENABLED

    // Message queues are created here and opened by components,

    // which will produce messages

    User::LeaveIfError( iStreamStatsQueue.CreateGlobal( KMccStreamStats,

            KNumOfStreamStatsSlots, EOwnerProcess ) );

    User::LeaveIfError( iCodecStatsQueue.CreateGlobal( KMccCodecStats,

            KNumOfCodecStatsSlots, EOwnerProcess ) );

    User::LeaveIfError( iJBufferStatsQueue.CreateGlobal( KMccJBufferStats,

            KNumOfJBufferStatsSlots, EOwnerProcess ) );

    #endif

	__CONTROLLER( "CMccController::ConstructL, exit" )

    }

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

// CMccController::GetSourceIdL

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

//

void CMccController::GetSourceIdL( TMMFMessage& aMessage )

    {

    MDataSource* dataSource = iResourcePool->SourceCandidate();

    __ASSERT_ALWAYS( dataSource, User::Leave( KErrNotFound ) );

    TMccSessionPckg pckg;

    aMessage.ReadData1FromClientL( pckg );

    pckg().iEndpointID = MCC_ENDPOINT_ID( dataSource );

    aMessage.WriteDataToClientL( pckg );

    }

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

// CMccController::GetSinkIdL

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

//

void CMccController::GetSinkIdL( TMMFMessage& aMessage )

    {

    MDataSink* dataSink = iResourcePool->SinkCandidate();

    __ASSERT_ALWAYS( dataSink, User::Leave( KErrNotFound ) );

    TMccSessionPckg pckg;

    aMessage.ReadData1FromClientL( pckg );

    pckg().iEndpointID = MCC_ENDPOINT_ID( dataSink );

    aMessage.WriteDataToClientL( pckg );

    }

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

// CMccController::CreateSessionL

// Creates new UlDlClient session

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

//

void CMccController::CreateSessionL( TMMFMessage& aMessage )

    {

	__CONTROLLER( "CMccController::CreateSessionL" )

    TMccCreateSessionPckg pckg;

    aMessage.ReadData1FromClientL( pckg );

    // Mcc ULDL Client -> NewL

    CMccUlDlClient* ulDlClient = 

        CMccUlDlClient::NewL( this, iResourcePool, iSessionIndex );

    CleanupStack::PushL( ulDlClient );

    iSessionArray.AppendL( ulDlClient );

    CleanupStack::Pop( ulDlClient );

	__CONTROLLER_INT1( "CMccController::CreateSessionL, session id", iSessionIndex )

    pckg().iSessionID = iSessionIndex;

    iSessionIndex++;

    aMessage.WriteDataToClientL( pckg );

	__CONTROLLER( "CMccController::CreateSessionL, exit" )

    }

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

// CMccController::CloseSessionL

// Closes UlDlClient

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

//

void CMccController::CloseSessionL( TMMFMessage& aMessage )

    {

	__CONTROLLER( "CMccController::CloseSessionL" )

    TMccSessionPckg pckg;

    aMessage.ReadData1FromClientL( pckg );

    TInt session = FindSessionL( pckg().iSessionID );

	TInt lastIndex = iCreatorArray.Count() - 1;

	for ( TInt i = lastIndex; i >= 0; i-- )

	    {

   		if ( iCreatorArray[i]->GetSessionId() == pckg().iSessionID )

			{

			delete iCreatorArray[i];

			iCreatorArray.Remove( i );

			}

	    }

    delete iSessionArray[session];

    iSessionArray.Remove( session );

	__CONTROLLER( "CMccController::CloseSessionL, exit" )

    }

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

// CMccController::CreateLinkL

// Creates new Ul/Dl Client

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

//

void CMccController::CreateLinkL( TMMFMessage& aMessage )

    {

	__CONTROLLER( "CMccController::CreateLinkL" )

    TMccCreateLinkPckg pckg;

    aMessage.ReadData1FromClientL( pckg );

    TInt session = FindSessionL( pckg().iSessionID );

    CMccAsyncLinkCreator* creator =

    CMccAsyncLinkCreator::NewLC( *this, iSessionArray[session] );

    creator->StartLinkCreationL( aMessage );

    iCreatorArray.AppendL( creator );

    CleanupStack::Pop( creator );

    }

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

// CMccController::CloseLinkL

// Closes a Ul/Dl Client

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

//

void CMccController::CloseLinkL( TMMFMessage& aMessage )

    {

	__CONTROLLER( "CMccController::CloseLinkL" )

    TMccGenericMsgBuffer pckg;

    aMessage.ReadData1FromClientL( pckg );

    TInt session = FindSessionL( pckg().iSessionID );

    iSessionArray[session]->CloseLinkL( pckg().iLinkID );

    // Remove DTMF payload associated with the closed link.

    TInt index = iDtmfPayloadTypes.Find( pckg().iLinkID, 

        TMccKeyValuePair<TUint32, TUint8>::CompareKey );

    if ( KErrNotFound != index )

        {

        __CONTROLLER_INT1( "CMccController::CloseLinkL, REMOVING DTMF PT: ",

             iDtmfPayloadTypes[index].Value() );

        iDtmfPayloadTypes.Remove( index );

        }

	__CONTROLLER( "CMccController::CloseLinkL, exit" )

    }

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

// CMccController::StartStreamL

// Starts stream

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

//

void CMccController::StartStreamL( TMMFMessage& aMessage )

    {

	__CONTROLLER( "CMccController::StartStreamL" )

    TMccStreamPckg pckg;

    aMessage.ReadData1FromClientL( pckg );

    TInt session = FindSessionL( pckg().iSessionID );

    iResourcePool->SetEnableRtcpL( pckg().iStreamID, pckg().iEnableRTCP );

    iSessionArray[session]->PlayL( pckg().iLinkID, pckg().iStreamID, pckg().iEndpointID,

                                         pckg().iStreamPaused,

                                         pckg().iEnableRTCP );

	__CONTROLLER( "CMccController::StartStreamL, exit" )

    }

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

// CMccController::StopStreamL

// Stops stream

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

//

void CMccController::StopStreamL( TMMFMessage& aMessage )

    {

	__CONTROLLER( "CMccController::StopStreamL" )

    TMccSessionPckg pckg;

    aMessage.ReadData1FromClientL( pckg );

    TInt session = FindSessionL( pckg().iSessionID );

    iSessionArray[session]->StopL( pckg().iLinkID, pckg().iStreamID,

    	pckg().iEndpointID );

	__CONTROLLER( "CMccController::StopStreamL, exit" )

    }

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

// CMccController::StartInactivityTimerL

// Starts inactivity timer for a stream in a given session.

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

//

void CMccController::StartInactivityTimerL( TMMFMessage& aMessage )

	{

	__CONTROLLER( "CMccController::StartInactivityTimerL" )

	TMccInactivityTimerPckg buffer;

    aMessage.ReadData1FromClientL( buffer );

    TInt session = FindSessionL( buffer().iSessionID );

    iSessionArray[session]->StartInactivityTimerL( buffer().iLinkID,

                                                   buffer().iStreamID,

                                                   buffer().iTimeoutTime );

	__CONTROLLER( "CMccController::StartInactivityTimerL, exit" )

	}	

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

// CMccController::StopInactivityTimerL

// Stops inactivity timer for a stream in a given session.

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

//

void CMccController::StopInactivityTimerL( TMMFMessage& aMessage )

	{

	__CONTROLLER( "CMccController::StopInactivityTimerL" )

	TMccGenericMsgBuffer buffer;

    aMessage.ReadData1FromClientL( buffer );

    TInt session = FindSessionL( buffer().iSessionID );

    iSessionArray[session]->StopInactivityTimerL( buffer().iLinkID,

                                                  buffer().iStreamID );

	__CONTROLLER( "CMccController::StopInactivityTimerL, exit" )

	}	

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

// CMccController::RequestEventNotificationL

// Requests Event notification

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

//

void CMccController::RequestEventNotificationL( TMMFMessage& aMessage )

    {

	__CONTROLLER( "CMccController::RequestEventNotificationL" )

    CancelMmfMessage();

    TMccEventPackage pckg;

    aMessage.ReadData1FromClientL( pckg );

    iMessage = new ( ELeave ) TMMFMessage( aMessage );

    SendEvent();

	__CONTROLLER( "CMccController::RequestEventNotificationL, exit" )

    }

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

// CMccController::SendEvent

// Calls SendEventL()

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

//

void CMccController::SendEvent()

    {

	__CONTROLLER( "CMccController::SendEvent" )

    TRAPD( err, SendEventL() );

    if ( err )

        {

        __CONTROLLER_INT1( "CMccController::SendEventL, leaved with err:", err )

        }

    }

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

// CMccController::SendEventL

// Sends event to clientside

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

//

void CMccController::SendEventL()

    {

    if ( iMessage && iEventBuf.Count() )

        {

        TMccEvent* event = iEventBuf[ 0 ];

        TMccEventPackage pckg( *event );

        iMessage->WriteDataToClientL( pckg );

        // 2) Complete the iMessage.

        iMessage->Complete( KErrNone ); 

        delete iMessage;

        iMessage = 0;

        iEventBuf.Remove( 0 );

        delete event;        

        }

    }

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

// CMccController::AddDataSinkL

// Adds data sink

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

//

void CMccController::AddDataSinkL( MDataSink& aSink )

    {

	__CONTROLLER( "CMccController::AddDataSinkL" )

	__CONTROLLER_INT1( "CMccController sink", aSink.DataSinkType().iUid )

    iResourcePool->ReserveSinkL( &aSink, MCC_ENDPOINT_ID( &aSink ) );

    }

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

// CMccController::AddDataSourceL

// Adds data source

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

//

void CMccController::AddDataSourceL( MDataSource& aSource )

    {

	__CONTROLLER( "CMccController::AddDataSourceL" )

	__CONTROLLER_INT1( "CMccController source", aSource.DataSourceType().iUid )

    iResourcePool->ReserveSourceL( &aSource, MCC_ENDPOINT_ID( &aSource ) );

    }

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

// CMccController::RemoveDataSourceL

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

//

void CMccController::RemoveDataSourceL( MDataSource& aDataSource )

    {

    RemoveEndpointL( MCC_ENDPOINT_ID( &aDataSource ) ); 

    }

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

// CMccController::RemoveDataSinkL

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

//

void CMccController::RemoveDataSinkL( MDataSink& aDataSink )

    {

    RemoveEndpointL( MCC_ENDPOINT_ID( &aDataSink ) ); 

    }

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

// CMccController::ResetL

// Not used

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

//

void CMccController::ResetL()

    {

    User::Leave( KErrNotSupported );

    }

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

// CMccController::PlayL

// Not used

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

//

void CMccController::PlayL()

    {

    User::Leave( KErrNotSupported );

    }

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

// CMccController::StopL

// Not used

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

//

void CMccController::StopL()