/*

* 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 <sipstrings.h>

#include <stringpool.h>

#include "mcemanager.h"

#include "mceinsessionobserver.h"

#include "mcesessionobserver.h"

#include "mceeventobserver.h"

#include "mcereferobserver.h"

#include "mcetransactionobserver.h" 

#include "mceintransactionobserver.h" 

#include "mceinsession.h"

#include "mceaudiocodec.h"

#include "mcevideocodec.h"

#include "mcefilesource.h"

#include "mceevent.h"

#include "mcerefer.h"

#include "mcetransactiondatacontainer.h"

#include "mce.h"

#include "mcemanagerreceiver.h"

#include "mceeventmanagerreceiver.h"

#include "mceitcsender.h"

#include "mceserial.h"

#include "mceevents.h"

#include "mceclilogs.h"

#include "mcecomfilesource.h"

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

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

// CMceManager::NewL

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

//

EXPORT_C CMceManager* CMceManager::NewL(

                        const TUid& aAppUid, 

						TMceTransactionDataContainer* aContainer )

    {

    CMceManager* self = 

        new (ELeave) CMceManager( aAppUid, aContainer );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CMceManager::~CMceManager

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

//

EXPORT_C CMceManager::~CMceManager()

    {

    MCECLI_DEBUG("CMceManager::~CMceManager, Entry");

    if (iContainer)

    	{

    	iContainer->Clear();

    	iContainer = 0;

    	}			

    iSessions.Reset();

    iSessions.Close();

    iEvents.Reset();

    iEvents.Close();

    iRefers.Reset();

    iRefers.Close();

    iSupportedAudioCodecs.ResetAndDestroy();

    iSupportedVideoCodecs.ResetAndDestroy();

    iTranscodingFiles.Reset();

    iTranscodingFiles.Close();

    delete iSender;

	delete iEventReceiver;

	delete iSessionReceiver;

	if (iServerSession)

        {

        iServerSession->Close();

        }

	delete iServerSession;

    MCECLI_DEBUG("CMceManager::~CMceManager, Exit");

    }

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

// CMceManager::SetInSessionObserver

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

//

EXPORT_C void CMceManager::SetInSessionObserver( 

                        MMceInSessionObserver* aInSessionObserver )

    {

    iInSessionObserver = aInSessionObserver;

    }

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

// CMceManager::SetInEventObserver

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

//

EXPORT_C void CMceManager::SetInEventObserver( 

                        MMceInEventObserver* aInEventObserver )

    {

    iInEventObserver = aInEventObserver;

    }

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

// CMceManager::SetInReferObserver

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

//

EXPORT_C void CMceManager::SetInReferObserver( 

                        MMceInReferObserver* aInReferObserver )

    {

    iInReferObserver = aInReferObserver;

    }

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

// CMceManager::SetSessionObserver

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

//

EXPORT_C void CMceManager::SetSessionObserver( 

                        MMceSessionObserver* aSessionObserver )

    {

    iSessionObserver = aSessionObserver;

    }

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

// CMceManager::SetEventObserver

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

//

EXPORT_C void CMceManager::SetEventObserver( 

                        MMceEventObserver* aEventObserver )

    {

    iEventObserver = aEventObserver;

    }

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

// CMceManager::SetReferObserver

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

//

EXPORT_C void CMceManager::SetReferObserver( 

                        MMceReferObserver* aReferObserver )

    {

    iReferObserver = aReferObserver;

    }

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

// CMceManager::SetTransactionObserver 

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

//

EXPORT_C void CMceManager::SetTransactionObserver( 

                        MMceTransactionObserver* aMceTransactionObserver )

    {

    iMceTransactionObserver = aMceTransactionObserver;

    }

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

// CMceManager::SetInTransactionObserver 

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

//

EXPORT_C void CMceManager::SetInTransactionObserver( 

                        MMceInTransactionObserver* aMceInTransactionObserver )

    {

    iMceInTransactionObserver = aMceInTransactionObserver;

    }    

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

// CMceManager::SetMediaObserver

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

//

EXPORT_C void CMceManager::SetMediaObserver( 

                        MMceStreamObserver* aMediaObserver )

    {

    iMediaObserver = aMediaObserver;

    }

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

// CMceManager::SetRtpObserver

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

//

EXPORT_C void CMceManager::SetRtpObserver( 

                        MMceRtpObserver* aRtpObserver )

    {

    iRtpObserver = aRtpObserver;

    }

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

// CMceManager::SetRtpObserver

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

//

EXPORT_C void CMceManager::SetDtmfObserver(

			 MMceDtmfObserver* aDtmfObserver )

	{

	iDtmfObserver = aDtmfObserver;	

	}

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

// CMceManager::SupportedAudioCodecs

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

//

EXPORT_C const RPointerArray<const CMceAudioCodec>&

CMceManager::SupportedAudioCodecs() const

    {

    return iSupportedAudioCodecs;

    }

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

// CMceManager::SupportedVideoCodecs

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

//

EXPORT_C const RPointerArray<const CMceVideoCodec>&

CMceManager::SupportedVideoCodecs() const

    {

    return iSupportedVideoCodecs;

    }

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

// CMceManager::Sessions

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

//

EXPORT_C const RPointerArray<CMceSession>& CMceManager::Sessions() const

    {

    return iSessions;

    }

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

// CMceManager::Events

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

//

EXPORT_C const RPointerArray<CMceEvent>& CMceManager::Events() const

    {

    return iEvents;

    }

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

// CMceManager::Refers

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

//

EXPORT_C const RPointerArray<CMceRefer>& CMceManager::Refers() const

    {

    return iRefers;

    }

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

// CMceManager::SetDefaultHeadersL

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

//

EXPORT_C void CMceManager::SetDefaultHeadersL( CDesC8Array* aMethods, 

                                               CDesC8Array* aHeaders )

    {

    MCECLI_DEBUG("CMceManager::SetDefaultHeadersL, Entry");

    TMceIds ids;

    PrepareForITC( ids, KMceCSSIPSession );

    TMceFactory factory;

    CMceMsgArray< TMceFactory >* msgArray = 

        new (ELeave) CMceMsgArray< TMceFactory >( factory );

    CleanupStack::PushL( msgArray ); 

    CMceMsgTextArray* methodsMsg = NULL;

    if ( aMethods )

        {

        methodsMsg = new ( ELeave ) CMceMsgTextArray( *aMethods );   

        }

    else

        {

        CDesC8Array* empty = new( ELeave ) CDesC8ArrayFlat( KMceArrayGranularity );

        CleanupStack::PushL( empty );

        methodsMsg = new ( ELeave ) CMceMsgTextArray( *empty );

        }

    CleanupStack::PushL( methodsMsg ); 

    msgArray->iArray.AppendL( methodsMsg ); 

    CleanupStack::Pop( methodsMsg );

    CMceMsgTextArray* hdrsMsg = NULL;

    if ( aHeaders )

        {

        hdrsMsg = new ( ELeave ) CMceMsgTextArray( *aHeaders );   

        }

    else

        {

        CDesC8Array* empty = new( ELeave ) CDesC8ArrayFlat( KMceArrayGranularity );

        CleanupStack::PushL( empty );

        hdrsMsg = new ( ELeave ) CMceMsgTextArray( *empty );

        }

    CleanupStack::PushL( hdrsMsg );

    msgArray->iArray.AppendL( hdrsMsg );

    CleanupStack::Pop( hdrsMsg );

    iSender->SendL( ids, EMceItcSetDefaultHeaders, *msgArray );  

    if ( !aHeaders )

        {

        CleanupStack::PopAndDestroy(); // empty

        }

    if ( !aMethods )

        {

        CleanupStack::PopAndDestroy(); // empty

        }

    CleanupStack::PopAndDestroy( msgArray );

    delete aMethods;

    delete aHeaders;

    MCECLI_DEBUG("CMceManager::SetDefaultHeadersL, Exit");

    }

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

// CMceManager::DefaultHeadersL

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

//

EXPORT_C CDesC8Array* CMceManager::DefaultHeadersL( const TDesC8& aMethod ) const

    {

    MCECLI_DEBUG("CMceManager::DefaultHeadersL, Entry");

    MCECLI_DEBUG_SVALUE("method", aMethod );

    CDesC8Array* headers = NULL;

    TMceIds ids;

    PrepareForITC( ids, KMceCSSIPSession );

 	headers = iSender->ReadArrayL( ids, EMceItcGetDefaultHeaders, aMethod );

    MCECLI_DEBUG("CMceManager::DefaultHeadersL, Exit");

 	return headers;

    }

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

// CMceManager::TranscodeL

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

//

TUint32 CMceManager::TranscodeL( CMceFileSource& aFile )

    {

    MCECLI_DEBUG("CMceManager::TranscodeL, Entry");

    MCECLI_DEBUG_SVALUE("file", aFile.FileInfo().iFileName );

    TMceIds ids;

    PrepareForITC( ids, KMceCSSIPSession );

    TMceItcFunctions itcFunc = EMceItcTranscode;

    CMceMsgBase* msg = NULL;

    if ( aFile.iStream && aFile.iStream->Session() )

        {

        msg = new (ELeave) CMceMsgObject<CMceSession>( 

                *aFile.iStream->Session(), EMceItcMsgTypeSession );

        itcFunc = EMceItcTranscodeWithSession;

        }

    else

        {

        msg = new (ELeave) CMceMsgObject<CMceMediaSource>( aFile, EMceItcMsgTypeSource );

        }

    CleanupStack::PushL( msg );

    iSender->SendL( ids, itcFunc, *msg );

    CleanupStack::PopAndDestroy( msg );

    iTranscodingFiles.AppendL( &aFile );

    MCECLI_DEBUG("CMceManager::TranscodeL, Exit");

    return ids.Get( KMceIdsIndexTCId );

    }

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

// CMceManager::CancelTranscodeL

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

//

void CMceManager::CancelTranscodeL( const CMceFileSource& aFile, TUint32 aSessionId )

    {

    MCECLI_DEBUG("CMceManager::CancelTranscodeL, Entry");

    MCECLI_DEBUG_DVALUE("session id", aSessionId );

    TInt index = iTranscodingFiles.Find( &aFile );

    User::LeaveIfError( index );

    TMceIds ids;

    PrepareForITC( ids, KMceCSSIPSession );

    TMceItcArgTUint32 sessionId( aSessionId );

    iSender->WriteL( ids, EMceItcCancelTranscode, sessionId );

    TranscodeCompleted( aFile );

    MCECLI_DEBUG("CMceManager::CancelTranscodeL, Exit");

    }

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

// CMceManager::TranscodeCompleted

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

//

void CMceManager::TranscodeCompleted( const CMceFileSource& aFile )

    {

    TInt index = iTranscodingFiles.Find( &aFile );

    if ( index >= 0 )

        {

        iTranscodingFiles.Remove( index );

        }

    }

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

// CMceManager::HandleIncomingEventL

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

//

void CMceManager::HandleIncomingEventL( TMceIds& aIds )

    {

    MCECLI_DEBUG("CMceManager::HandleIncomingEventL, Entry");

    CMceFileSource* session = NULL;

    TInt index = 0;

    TInt status = KMceEventNotConsumed;

    while( status == KMceEventNotConsumed && index < iTranscodingFiles.Count() )

        {

        TMceEvent event( aIds, NULL, NULL );

        session = iTranscodingFiles[index];

        status = session->EventReceivedL( event );

        status = status == KMceEventNotOwner ? KMceEventNotConsumed : status;

        index++;

        }

    MCECLI_DEBUG("CMceManager::HandleIncomingEventL, Exit");        

    }

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

// CMceManager::FindAssociatedSession

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

//	

CMceSession* CMceManager::FindAssociatedSession( TUint32 aDialogId ) const

    {

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

        {

        if ( aDialogId == iSessions[ i ]->DialogId() )

            {

            return iSessions[ i ];

            }

        }

    return NULL;

    }

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

// CMceManager::InSessionObserver

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

//

MMceInSessionObserver* CMceManager::InSessionObserver() const

    {

    return iInSessionObserver;

    }

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

// CMceManager::InEventObserver

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

//

MMceInEventObserver* CMceManager::InEventObserver() const

    {

    return iInEventObserver;

    }

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

// CMceManager::InReferObserver

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

//

MMceInReferObserver* CMceManager::InReferObserver() const

    {

    return iInReferObserver;

    }

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

// CMceManager::SessionObserver

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

//

MMceSessionObserver* CMceManager::SessionObserver() const

    {

    return iSessionObserver;

    }

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

// CMceManager::MediaObserver

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

//

MMceStreamObserver* CMceManager::MediaObserver() const

    {

    return iMediaObserver;

    }

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

// CMceManager::RtpObserver

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