/*

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

*

*/

// INCLUDE FILES

#include "MmccInterface_stub.h"

#include "CMccController_stub.h"

#include <MmccNetworkSettings.h>

#include <mmccevents.h>

#include "MmccCodecAMR.h"

#include "MmccCodecDTMF.h"

#include <MmccCodecInformation.h>

#include <MmccCodecInformationFactory.h>

#include "MmccInterfaceLogs.h"

#include <ECam.h>

// These have to be same as in rtpdef.h, but can not include rtpdef.h here,

// since that results compilation errors for redefinition of TRtpPeerStat and

// TTimeStamps

//typedef TUint32 TRtpId;

//const TRtpId KNullId = 0xffffffff;

const TUid KImplementMccController  = { 0 };

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

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

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

// CMccInterface::CMccInterface

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

// might leave.

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

//

CMccInterface::CMccInterface() 

    {

    }

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

// CMccInterface::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CMccInterface::ConstructL( MMccCtrlObserver& aObserver )

    {

	__INTERFACE( "MccInterface::ConstructL" )

    TInt err = KErrNone;

    // Open Controller

    err = OpenController( KImplementMccController );

    if ( err )

        {

        User::Leave( err );

        }

	// No need to ask CMccControllerStub here, since OpenController() created

	// it when necessary.

    iController->iObserver = &aObserver;

    //iMccEvent = CMccEvent::NewL( iController, aObserver );

    //iMccEvent->RequestEventNotification();

	CapabilitiesL();

	__INTERFACE( "MccInterface::ConstructL, exit" )

    }

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

// CMccInterface::NewL()

// Static constructor.

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

//

EXPORT_C CMccInterface* CMccInterface::NewL( MMccCtrlObserver& aObserver )

    {

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

    CleanupStack::PushL( self );

    self->ConstructL( aObserver );

    CleanupStack::Pop( self );

    return self;

    }

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

// CMccInterface::~CMccInterface()

// Destructor

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

//

CMccInterface::~CMccInterface()

    {

	__INTERFACE( "MccInterface::~CMccInterface" )

	// Always ask controller stub, since if there are multiple CMccInterface

	// instances, and one of them closes controller, the other CMccInterface

	// instances wouldn't know it.

	CMccControllerStub* ctrl = CMccControllerStub::Stub();

	if ( ctrl )

		{

		ctrl->Close();

		}

    iCodecInformation.ResetAndDestroy();

    iCodecInformation.Close();

	__INTERFACE( "MccInterface::~CMccInterface, exit" )

    }

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

// CMccInterface::CapabilitiesL()

// Get supported codecs from controller.

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

//

void CMccInterface::CapabilitiesL()

    {

	__INTERFACE( "MccInterface::CapabilitiesL" )

    RArray<TFourCC> codecs;     

    CleanupClosePushL( codecs );       

    CMccCodecInformationFactory* codecFactory = CMccCodecInformationFactory::NewL();

    CleanupStack::PushL( codecFactory );

    User::LeaveIfError( GetSupportedCodecs( codecs ) );

    TFourCC fourCCValue;

	__INTERFACE_INT1( "MccInterface::CapabilitiesL, count of found codecs:", codecs.Count() )

    for ( TInt k = 0; k < codecs.Count(); k++ )

        {

        fourCCValue = codecs[k];

        CMccCodecInformation* codec = codecFactory->CreateCodecInformationL( fourCCValue );

        if ( codec )

            {

            CleanupStack::PushL( codec );

			__INTERFACE_STR8( "MccInterface::CapabilitiesL, appending:", codec->SdpName() )

            iCodecInformation.AppendL( codec );            

            CleanupStack::Pop( codec );

            }

        }

    CleanupStack::PopAndDestroy( codecFactory );

    CleanupStack::PopAndDestroy( &codecs );

	__INTERFACE( "MccInterface::CapabilitiesL, exit" )

    }

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

// CMccInterface::GetSupportedCodecs()

// Get supported codecs.

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

//

TInt CMccInterface::GetSupportedCodecs( RArray<TFourCC>& aCodecs )

    {

	__INTERFACE( "MccInterface::GetSupportedCodecs" )

	// Always ask controller stub, since if there are multiple CMccInterface

	// instances, and one of them closes controller, the other CMccInterface

	// instances wouldn't know it.

	TInt err( KErrNone );

	CMccControllerStub* ctrl = CMccControllerStub::Stub();

	if ( ctrl )

		{

		err = ctrl->ControllerCalled( CMccControllerStub::EMccGetSupportedCodecs );

		}

	else

		{

		return KErrNotFound;

		}

/*    

    TMccSession session;

    TInt count = session.iFourCCArray.Count();

    for ( TInt i = 0; i < count; i++)

        {

        session.iFourCCArray[i] = NULL;

        }

    TMccSessionPckg package( session );

    err = iController.CustomCommandSync( iMessageDest,

                                         EMccGetSupportedCodecs,

                                         package,

                                         KNullDesC8,

                                         package );

    if ( !err ) 

        {

        count =  package().iFourCCArray.Count();

		__INTERFACE_INT1( "MccInterface::GetSupportedCodecs, found", count )

        for( TInt i = 0; i < count; i++ )

            {

            if ( package().iFourCCArray[i] != NULL )

                {

                aCodecs.Append( package().iFourCCArray[i] );

                }

            }

        }

  */

    if ( !err )

        {

        err = aCodecs.Append( KMccFourCCIdAMRNB );

        if ( !err )

            {

            err = aCodecs.Append( KMccFourCCIdH263 );

            }

        }

	__INTERFACE_INT1( "MccInterface::GetSupportedCodecs, exit with ", err )

    return err;

    }

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

// CMccInterface::OpenController()

// Opens Mcc Controller

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

//

TInt CMccInterface::OpenController( const TUid& /*aControllerUid*/ )

    {

	__INTERFACE( "MccInterface::OpenController" )

    TRAPD( error, CMccControllerStub::OpenL() );

    iController = CMccControllerStub::Stub();

    if ( iController && !error )

        {

        error = iController->iLeaveError; 

        }

    /*

    TMMFPrioritySettings settings;

    settings.iPriority = EPriorityNormal;

    error = iController.Open( aControllerUid, settings );

    if ( error )

        {

        iController.Close();

        }

    */

	__INTERFACE_INT1( "MccInterface::OpenController, exit with", error)

    return error;

    }

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

// CMccInterface::SetRemoteAddress

// Set remote IP address and port number for a given RTP session.

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

//

EXPORT_C TInt CMccInterface::SetRemoteAddress(  TUint32 aSessionId, TUint32 aLinkId,

                                               const TInetAddr& /*aRemoteAddr*/, 

                                               TUint /*aRemoteRtcpPort*/ )

    {

	__INTERFACE( "MccInterface::SetRemoteAddress" )

	// Always ask controller stub, since if there are multiple CMccInterface

	// instances, and one of them closes controller, the other CMccInterface

	// instances wouldn't know it.

	TInt err( KErrNotFound );

	CMccControllerStub* ctrl = CMccControllerStub::Stub();

	if ( ctrl )

		{

		err = ctrl->ControllerCalled( CMccControllerStub::EMccSetRemoteAddress,

									  aSessionId,

									  aLinkId );

		}

    /*

    TMccAddress addr;

    addr.iSessionID = aSessionId;

    addr.iLinkID = aLinkId;

    addr.iAddress = aRemoteAddr;

    TMccAddressPckg package( addr );

    err = iController.CustomCommandSync( iMessageDest,

                                         EMccSetRemoteAddress,

                                         package,

                                         KNullDesC8 );

    */

	__INTERFACE_INT1( "MccInterface::SetRemoteAddress, exit with ", err )

    return err;

    }

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

// CMccInterface::CreateSession

// Creates a new RTP session with a remote participant.

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

//

EXPORT_C TInt CMccInterface::CreateSession( TUint32& aSessionId )

    {

	__INTERFACE( "MccInterface::CreateSession" )

	// Always ask controller stub, since if there are multiple CMccInterface

	// instances, and one of them closes controller, the other CMccInterface

	// instances wouldn't know it.

	TInt result( KErrNotFound );

	CMccControllerStub* ctrl = CMccControllerStub::Stub();

	if ( ctrl )

		{

		result = ctrl->ControllerCalled( CMccControllerStub::EMccCreateSession );

		aSessionId = ctrl->NextSessionId();

		__INTERFACE_INT1( "MccInterface::CreateSession, sesid ", aSessionId )

		}

	/*

    TMccCreateSession pktSession;

    TMccCreateSessionPckg package( pktSession );

    TInt result = iController.CustomCommandSync( iMessageDest,

                                                 EMccCreateSession,

                                                 package,

                                                 KNullDesC8,

                                                 package );

    if ( result == KErrNone )

        {

        aSessionId = package().iSessionID;

        }

    */

	__INTERFACE_INT1( "MccInterface::CreateSession, exit with ", result )

    return result;

    }

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

// CMccInterface::CreateLink

// Creates a new Mcc link with a remote participant.

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

//

EXPORT_C TInt CMccInterface::CreateLink( TUint32 aSessionId,

                                         TInt aLinkType,

                                         TUint32& aLinkId,

                                         TMccNetSettings& /*aNetSettings*/ )

    {    

	__INTERFACE( "MccInterface::CreateLink")

	// Always ask controller stub, since if there are multiple CMccInterface

	// instances, and one of them closes controller, the other CMccInterface

	// instances wouldn't know it.

	TInt result( KErrNotFound );

	CMccControllerStub* ctrl = CMccControllerStub::Stub();

	if ( ctrl )

		{

		result = ctrl->ControllerCalled( CMccControllerStub::EMccCreateLink,

				                  		aSessionId,

				                  		KMceNotAssigned,

				                  		KMceNotAssigned,

				                  		KMceNotAssigned,

				                  		aLinkType );

		aLinkId = ctrl->NextLinkId();

		__INTERFACE_INT1( "MccInterface::CreateLink, lid ", aLinkId )

		}

    /*	

    TMccCreateLink pktLink;

    pktLink.iSessionID = aSessionId;

    pktLink.iLinkType = aLinkType;

    pktLink.iIapId = aNetSettings.iIapId;

    pktLink.iAddress = aNetSettings.iRemoteAddress;

    pktLink.iPort = aNetSettings.iLocalPort;

    pktLink.iMediaSignaling = aNetSettings.iMediaSignalling;

    TMccCreateLinkPckg package( pktLink );

    TInt result = iController.CustomCommandSync( iMessageDest,

                                                 EMccCreateLink,

                                                 package,

                                                 KNullDesC8,

                                                 package );

    if ( result == KErrNone )

        {

        aNetSettings.iLocalPort = package().iPort;

        aLinkId = package().iLinkID;

        }*/

	__INTERFACE_INT1( "MccInterface::CreateLink, exit with ", result )

    return result;

    }

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

// CMccInterface::CloseSession

// Closes RTP session.

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

//

EXPORT_C TInt CMccInterface::CloseSession( TUint32 aSessionId )

    {

	__INTERFACE_INT1( "MccInterface::CloseSession, sesid ", aSessionId )

	// Always ask controller stub, since if there are multiple CMccInterface

	// instances, and one of them closes controller, the other CMccInterface

	// instances wouldn't know it.

	TInt err( KErrNotFound );

	CMccControllerStub* ctrl = CMccControllerStub::Stub();

	if ( ctrl )

		{

		err = ctrl->ControllerCalled( CMccControllerStub::EMccCloseSession,

									  aSessionId );

		}

/*    

    TMccSession sessID;

    sessID.iSessionID = aSessionId;

    TMccSessionPckg package( sessID );

    err = iController.CustomCommandSync( iMessageDest,

                                         EMccCloseSession,

                                         package,

                                         KNullDesC8 );

*/

	__INTERFACE_INT1( "MccInterface::CloseSession, exit with ", err )

    return err;

    }

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

// CMccInterface::CloseLink

// Closes Mcc link.

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

//

EXPORT_C TInt CMccInterface::CloseLink( TUint32 aSessionId, TUint32 aLinkId )

    {

	__INTERFACE_INT1( "MccInterface::CloseLink, lid ", aLinkId )

	// Always ask controller stub, since if there are multiple CMccInterface

	// instances, and one of them closes controller, the other CMccInterface

	// instances wouldn't know it.

	TInt err( KErrNotFound );

	CMccControllerStub* ctrl = CMccControllerStub::Stub();

	if ( ctrl )

		{

		err = ctrl->ControllerCalled( CMccControllerStub::EMccCloseLink,

									  aSessionId,

									  aLinkId );

		}

    /*

    TMccGenericMessage message;

    message.iSessionID = aSessionId;

    message.iLinkID = aLinkId;

    TMccGenericMsgBuffer package( message );

    err = iController.CustomCommandSync( iMessageDest,

                                         EMccCloseLink,

                                         package,

                                         KNullDesC8 );

    */                                         

	__INTERFACE_INT1( "MccInterface::CloseLink, exit with ", err )

    return err;

    }

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

// CMccInterface::CreateStream

// Creates a stream to a RTP session.

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

//

EXPORT_C TInt CMccInterface::CreateStream( TUint32 aSessionId, 

                                           TUint32 aLinkId,

                                           TUint32& aStreamId,

                                           TInt aStreamType,

                                           CMccCodecInformation& aCodecInformation )

    {

	__INTERFACE( "MccInterface::CreateStream" )

	// Always ask controller stub, since if there are multiple CMccInterface

	// instances, and one of them closes controller, the other CMccInterface

	// instances wouldn't know it.

	TInt err( KErrNotFound );

	CMccControllerStub* ctrl = CMccControllerStub::Stub();

	if ( ctrl )

		{

		err = ctrl->ControllerCalled( CMccControllerStub::EMccCreateStream,

									  aSessionId, 

                                      aLinkId,

                                      KMceNotAssigned,

                                      KMceNotAssigned, 

                                      KMceNotAssigned,

                                      aStreamType );

		aStreamId = ctrl->NextStreamId();

		__INTERFACE_INT1( "MccInterface::CreateStream, sid ", aStreamId )

		}

    /*

    TMccGenericMessage genMessage;

    genMessage.iSessionID = aSessionId;

    genMessage.iLinkID = aLinkId;

    TMccGenericMsgBuffer msgBuffer( genMessage );

    TMccCreateStreamParam message;

    message.iPayloadType = aCodecInformation->PayloadType();

    message.iFourCC = aCodecInformation->FourCC();

    message.iStreamType = aStreamType;

    message.iPrioritySettings.iPriority = aCodecInformation->Priority();

    message.iPrioritySettings.iPref =

    	TMdaPriorityPreference( aCodecInformation->PriorityPreference() );

    TMccCreateStreamParamPckg messagePckg( message );