/*

* Copyright (c) 2004-2008 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 <ecom/ecom.h>

#include <mmf/common/mmfbase.h>

#include <ecam.h>

#include "mmccinterface.h"

#include "mmcctranscoder.h"

#include "mccuids.hrh"

#include "mccinternalcodecs.h"

#include "mmccnetworksettings.h"

#include "mccdef.h"       

#include "mmccevent.h"

#include "mmcccodecamr.h"

#include "mmcccodecdtmf.h"

#include "mmcccodecinformation.h"

#include "mmcccodecinformationfactory.h"

#include "mmccevents.h"

#include "mmccinterfacelogs.h"

#include "mmcccodech263.h"

const TUid KImplementMccController  = { KImplUidMccController };

// 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() : 

    iMessageDest( KMccControllerUidInterface ),

    iAudioPlayDeviceCustomCommands( iController ),

    iAudioRecordDeviceCustomCommands( iController )

    {

    }

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

// CMccInterface::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CMccInterface::ConstructL( MMccCtrlObserver& aObserver )

    {

    __INTERFACE( "MccInterface::ConstructL" )

    // Open Controller

    OpenControllerL( KImplementMccController );

    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" )

    delete iMccEvent;

    iController.Close();

    iCodecInformation.ResetAndDestroy();

    iCodecInformation.Close();

    iEndpointInfos.Reset();

    iEndpointInfos.Close();

    REComSession::FinalClose();

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

    }

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

// CMccInterface::CapabilitiesL()

// Get supported codecs from controller.

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

//

void CMccInterface::CapabilitiesL()

    {

    __INTERFACE( "MccInterface::CapabilitiesL" )

    RArray<TFourCC> codecs;            

    CMccCodecInformationFactory* codecFactory = CMccCodecInformationFactory::NewL();

    CleanupStack::PushL( codecFactory );

    GetSupportedCodecs( codecs );

    TFourCC fourccValue;

    TInt codecCount = codecs.Count();

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

    for ( TInt k = 0; k < codecCount; 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 );

            }

        if ( fourccValue == KMccFourCCIdG711 )

            {

            codec = codecFactory->CreateCodecInformationL( fourccValue );

            CleanupStack::PushL( codec );

            if ( 0 == codec->SdpName().CompareF( KPCMUSdpName ) )

                {

                codec->SetSdpName( KPCMASdpName );

                }

            else

                {

                codec->SetSdpName( KPCMUSdpName );

                }

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

            iCodecInformation.AppendL( codec );

            CleanupStack::Pop( codec );

            }

        if ( fourccValue == KMccFourCCIdH263 )

            {

            codec = codecFactory->CreateCodecInformationL( fourccValue );

            CleanupStack::PushL( codec );

            if ( 0 == codec->SdpName().CompareF( KH2632000SdpName ) )

                {

                // Changes also sdpname

                codec->SetCodecMode( KH263FormatModeOld );

                }

            else

                {

                // Changes also sdpname

                codec->SetCodecMode( KH263FormatModeNew );

                }

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

            iCodecInformation.AppendL( codec );

            CleanupStack::Pop( codec );

            }

        }

    codecs.Close();

    CleanupStack::PopAndDestroy( codecFactory );

    __INTERFACE( "MccInterface::CapabilitiesL, exit" )

    }

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

// CMccInterface::GetSupportedCodecs()

// Get supported codecs.

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

//

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

    {

    __INTERFACE( "MccInterface::GetSupportedCodecs" )

    TInt err = KErrNone;

    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] );

                }

            }

        }

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

    return err;

    }

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

// CMccInterface::OpenControllerL()

// Opens Mcc Controller

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

//

void CMccInterface::OpenControllerL( const TUid& aControllerUid )

    {

    __INTERFACE( "MccInterface::OpenControllerL" )

    TInt error = KErrNone;

    TMMFPrioritySettings settings;

    settings.iPriority = EPriorityNormal;

    CMMFControllerImplementationInformation* implInfo = 

        CMMFControllerImplementationInformation::NewL( aControllerUid );

    CleanupStack::PushL( implInfo );

    __INTERFACE_INT1( "MccInterface::OpenController, heapsize:", 

                      implInfo->HeapSpaceRequired() )

    error = iController.Open( *implInfo, settings );

    if ( error )

        {

        iController.Close();

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

        User::Leave( error );

        }

    CleanupStack::PopAndDestroy( implInfo );

    __INTERFACE_INT1( "MccInterface::OpenController, exit with", 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" )

    TInt err = KErrNone;

    TMccAddress addr;

    addr.iSessionID = aSessionId;

    addr.iLinkID = aLinkId;

    addr.iAddress = aRemoteAddr;

    TMccAddressPckg package( addr );

	if ( aRemoteRtcpPort == 0 )

		{

		err = iController.CustomCommandSync( iMessageDest,

                                         EMccSetRemoteAddress,

                                         package,

                                         KNullDesC8 );

		}

	if ( aRemoteRtcpPort != 0)

		{

		 __INTERFACE_INT1( "RtcpPort = ", aRemoteRtcpPort )

   		err = iController.CustomCommandSync( iMessageDest,

                                         EMccSetRemoteRtcpAddr,

                                         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" )

    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")

    TMccCreateLink pktLink;

    pktLink.iSessionID = aSessionId;

    pktLink.iLinkType = aLinkType;

    pktLink.iIapId = aNetSettings.iIapId;

    pktLink.iRemoteAddress = aNetSettings.iRemoteAddress;

    pktLink.iLocalAddress.SetPort( aNetSettings.iLocalAddress.Port() );

    pktLink.iIpTOS = aNetSettings.iMediaQosValue;

    TMccCreateLinkPckg package( pktLink );

    TInt result = iController.CustomCommandSync( iMessageDest,

                                                 EMccCreateLink,

                                                 package,

                                                 KNullDesC8,

                                                 package );

    if ( KErrNone == result )

        {

        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( "MccInterface::CloseSession" )

    TInt err = KErrNone;

    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( "MccInterface::CloseLink" )

    TInt err = KErrNone;

    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" )

    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() );

    message.iStandByTimer = aCodecInformation.JitterBufInactivityTimeOut();

    TMccCreateStreamParamPckg messagePckg( message );

    /* Call the controller */

    TInt err = iController.CustomCommandSync( iMessageDest, EMccCreateStream,

                                         msgBuffer, messagePckg,

                                         msgBuffer );

    if( err != KErrNone )

        {

        return err;

        }

    aStreamId = msgBuffer().iStreamID;

    err = this->SetCodec( aSessionId, aLinkId, aStreamId, aCodecInformation );

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

    return err;

    }

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

// CMccInterface::DeleteStream

// Deletes media stream in a given session.

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

//

EXPORT_C TInt CMccInterface::DeleteStream( TUint32 aSessionId, 

                                           TUint32 aLinkId, 

                                           TUint32 aStreamId )

    {

    __INTERFACE( "MccInterface::DeleteStream" )

    TInt err = KErrNone;

    TMccSession sessID;

    sessID.iSessionID = aSessionId;

    sessID.iLinkID = aLinkId;

    sessID.iStreamID = aStreamId;

    TMccSessionPckg package( sessID );

    err = iController.CustomCommandSync( iMessageDest,

                                         EMccDeleteStream,

                                         package,

                                         KNullDesC8 );

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

    return err;

    }

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

// CMccInterface::StartInactivityTimer

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

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

//

EXPORT_C TInt CMccInterface::StartInactivityTimer( TUint32 aSessionId,

                                                   TUint32 aLinkId,

                                                   TUint32 aStreamId,

                                                   TUint32 aTimeoutTime,

                                                   TUint32 /*aEndpointId*/ )

    {

    __INTERFACE( "MccInterface::StartInactivityTimer" )

    TMccInactivityTimer inactivityTimer;

    inactivityTimer.iSessionID = aSessionId;

    inactivityTimer.iLinkID = aLinkId;

    inactivityTimer.iStreamID = aStreamId;

    inactivityTimer.iTimeoutTime = aTimeoutTime;

    TMccInactivityTimerPckg package( inactivityTimer );

    TInt err = iController.CustomCommandSync( iMessageDest,

                                              EMccInactivityTimerStart,

                                              package,

                                              KNullDesC8 );

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