/*

* Copyright (c) 2006 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:    

*

*/

// INCLUDES

#include "test_interface.h"

#include "mmcccodecinformation.h"

#include "mccteststubs.h"

#include "mmccinterface.h"

#include "testdefinitions.hrh"

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

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

// CTestInterfaceInterface::CTestInterfaceInterface

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

// might leave.

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

//

CTestInterface::CTestInterface( CConsoleBase& aConsole,

    const TMccNetSettings& aSettings, CMccInterface& aIF, CMccInterfaceStub& aIFStub )

    :

    iConsole( aConsole ), iNetsettings( aSettings ), iInterface( aIF ),

    iIfStub( aIFStub )

    {

    }

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

// CTestInterface::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CTestInterface::ConstructL()

    {

    }

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

// CTestInterface::NewL

// Static constructor.

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

//   

CTestInterface* CTestInterface::NewL( CConsoleBase& aConsole,

    const TMccNetSettings& aSettings, CMccInterface& aIF, CMccInterfaceStub& aIFStub )

    {

    CTestInterface* self 

        = new ( ELeave ) CTestInterface( aConsole, aSettings, aIF, aIFStub );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CTestInterface::~CTestInterface

// Destructor.

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

//

CTestInterface::~CTestInterface()

    {

    }

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

// CTestInterface::DoRunInterfaceTestsL

// 

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

//

void CTestInterface::DoRunInterfaceTestsL()

    {

    iConsole.ClearScreen();

    iConsole.Printf( _L("\n*** INTERFACE TESTS ***\n") );

    TInt err( KErrNone );

    iConsole.Printf( _L("GET CAPABILITIES\n") );

    RDebug::Print( _L("Mcc_COM_TEST_START: TestGetCapabilitiesL") );

    __UHEAP_MARK;

    TRAP( err, TestGetCapabilitiesL() );

    __UHEAP_MARKEND;

    RDebug::Print( _L("Mcc_COM_TEST_STOP: TestGetCapabilitiesL, ERR: %d"), err );

    iConsole.Printf( _L("CREATE SINGLE SESSION\n") );

    RDebug::Print( _L("Mcc_COM_TEST_START: TestSingleSessionCreationL") );

    __UHEAP_MARK;

    TRAP( err, TestSingleSessionCreationL() );

    __UHEAP_MARKEND;

    RDebug::Print( _L("Mcc_COM_TEST_STOP: TestSingleSessionCreationL, ERR: %d"), err );

    iConsole.Printf( _L("CREATE SINGLE LINK\n") );

    RDebug::Print( _L("Mcc_COM_TEST_START: TestSingleLinkCreationL") );

    __UHEAP_MARK;

    TRAP( err, TestSingleLinkCreationL() );

    __UHEAP_MARKEND;

    RDebug::Print( _L("Mcc_COM_TEST_STOP: TestSingleLinkCreationL, ERR: %d"), err );

    iConsole.Printf( _L("CREATE SINGLE STREAM\n") );

    RDebug::Print( _L("Mcc_COM_TEST_START: TestSingleStreamCreationL") );

    //__UHEAP_MARK;

    TRAP( err, TestSingleStreamCreationL() );

    //__UHEAP_MARKEND;

    RDebug::Print( _L("Mcc_COM_TEST_STOP: TestSingleStreamCreationL, ERR: %d"), err );

    iConsole.Printf( _L("PREPARE SINGLE STREAM\n") );

    RDebug::Print( _L("Mcc_COM_TEST_START: TestSingleStreamPreparingL") );

    __UHEAP_MARK;

    iConsole.Printf( _L("Audio uplink\n") );

    TRAP( err, TestSingleStreamPreparingL( KMccLinkGeneral, KMccAudioUplinkStream,

        KUidMmfAudioInput, KMccRtpSinkUid, KAMRSdpName ) );

    __UHEAP_MARKEND;

    iConsole.Printf( _L("Audio downlink\n") );

    __UHEAP_MARK;

    TRAP( err, TestSingleStreamPreparingL( KMccLinkGeneral, KMccAudioDownlinkStream,

        KMccRtpSourceUid, KUidMmfAudioOutput, KAMRSdpName ) );

    __UHEAP_MARKEND;

    //TestSingleStreamPreparingL( KPCMUSdpName );

    //TestSingleStreamPreparingL( KPCMASdpName );

    //TestSingleStreamPreparingL( KILBCSdpName );

    //TestSingleStreamPreparingL( KG729SdpName );

    __UHEAP_MARK;

    iConsole.Printf( _L("Invalid source/sink 1\n") );

    // INVALID SOUCE/SINK, SHOULD NOT PASS TEST

    TRAP( err, TestSingleStreamPreparingL( KMccLinkGeneral, KMccAudioUplinkStream,

        KMccRtpSourceUid, KUidMmfAudioOutput, KAMRSdpName ) );

    __UHEAP_MARKEND;

    __UHEAP_MARK;

    iConsole.Printf( _L("Invalid source/sink 2\n") );

    // INVALID SOUCE/SINK, SHOULD NOT PASS TEST

    TRAP( err, TestSingleStreamPreparingL( KMccLinkGeneral, KMccAudioDownlinkStream,

        KUidMmfAudioInput, KMccRtpSinkUid, KAMRSdpName ) );

    __UHEAP_MARKEND;

    RDebug::Print( _L("Mcc_COM_TEST_STOP: TestSingleStreamPreparingL, ERR: %d"), err );

    iConsole.Printf( _L("PLAY SINGLE STREAM\n") );

    iConsole.Printf( _L("Audio uplink\n") );

    RDebug::Print( _L("Mcc_COM_TEST_START: TestSingleStreamPlayingL") );

    __UHEAP_MARK;

    TRAP( err, TestSingleStreamPlayingL( KMccLinkGeneral, KMccAudioUplinkStream,

        KUidMmfAudioInput, KMccRtpSinkUid, KAMRSdpName ) );

    __UHEAP_MARKEND;

    __UHEAP_MARK;

    iConsole.Printf( _L("Audio downlink\n") );

    TRAP( err, TestSingleStreamPlayingL( KMccLinkGeneral, KMccAudioDownlinkStream,

        KMccRtpSourceUid, KUidMmfAudioOutput, KAMRSdpName ) );

    __UHEAP_MARKEND;

    RDebug::Print( _L("Mcc_COM_TEST_STOP: TestSingleStreamPlayingL, ERR: %d"), err );

    iConsole.Printf( _L("PAUSE SINGLE STREAM\n") );

    RDebug::Print( _L("Mcc_COM_TEST_START: TestSingleStreamPausingL") );

    __UHEAP_MARK;

    iConsole.Printf( _L("Audio uplink\n") );

    TRAP( err, TestSingleStreamPausingL( KMccLinkGeneral, KMccAudioUplinkStream,

        KUidMmfAudioInput, KMccRtpSinkUid, KAMRSdpName ) );

    __UHEAP_MARKEND;

    __UHEAP_MARK;

    iConsole.Printf( _L("Audio downlink\n") );

    TRAP( err, TestSingleStreamPausingL( KMccLinkGeneral, KMccAudioDownlinkStream,

        KMccRtpSourceUid, KUidMmfAudioOutput, KAMRSdpName ) );

    __UHEAP_MARKEND;

    RDebug::Print( _L("Mcc_COM_TEST_STOP: TestSingleStreamPausingL, ERR: %d"), err );

    iConsole.Printf( _L("MUTE AUDIO\n") );

    RDebug::Print( _L("Mcc_COM_TEST_START: TestAudioMuteL") );

    //__UHEAP_MARK;

    TRAP( err, TestAudioMuteL() );

    //__UHEAP_MARKEND;

    RDebug::Print( _L("Mcc_COM_TEST_STOP: TestAudioMuteL, ERR: %d"), err );

    iConsole.Printf( _L("SET CODEC\n") );

    RDebug::Print( _L("Mcc_COM_TEST_START: TestSetCodecL") );

    __UHEAP_MARK;

    TRAP( err, TestSetCodecL() );

    __UHEAP_MARKEND;

    RDebug::Print( _L("Mcc_COM_TEST_STOP: TestSetCodecL, ERR: %d"), err );

    iConsole.Printf( _L("GET CODEC\n") );

    RDebug::Print( _L("Mcc_COM_TEST_START: TestGetCodecL") );

    //__UHEAP_MARK;

    TRAP( err, TestGetCodecL() );

    //__UHEAP_MARKEND;

    RDebug::Print( _L("Mcc_COM_TEST_STOP: TestGetCodecL, ERR: %d"), err );

    iConsole.Printf( _L("GET SSRC\n") );

    RDebug::Print( _L("Mcc_COM_TEST_START: TestGetSSRCL") );

    __UHEAP_MARK;

    TRAP( err, TestGetSSRCL() );

    __UHEAP_MARKEND;

    RDebug::Print( _L("Mcc_COM_TEST_STOP: TestGetSSRCL, ERR: %d"), err );

    iConsole.Printf( _L("INACTIVITY TIMER\n") );

    RDebug::Print( _L("Mcc_COM_TEST_START: TestInactivityTimerL") );

    __UHEAP_MARK;

    TRAP( err, TestInactivityTimerL() );

    __UHEAP_MARKEND;

    RDebug::Print( _L("Mcc_COM_TEST_STOP: TestInactivityTimerL, ERR: %d"), err );

    iConsole.Printf( _L("FAST SHUTDOWNS\n") );

    RDebug::Print( _L("Mcc_COM_TEST_START: TestFastShutdownsL") );

    //__UHEAP_MARK;

    TRAP( err, TestFastShutdownsL() );

    //__UHEAP_MARKEND;

    RDebug::Print( _L("Mcc_COM_TEST_STOP: TestFastShutdownsL, ERR: %d"), err );

    iConsole.Printf( _L("CREATE MULTI STREAM/LINK/SESSION\n") );

    RDebug::Print( _L("Mcc_COM_TEST_START: TestMultiStreamLinkSessionL") );

    //__UHEAP_MARK;

    TRAP( err, TestMultiStreamLinkSessionL() );

    //__UHEAP_MARKEND;

    RDebug::Print( _L("Mcc_COM_TEST_STOP: TestMultiStreamLinkSessionL, ERR: %d"), err );

    iConsole.Printf( _L("MULTI STREAM PREPARE\n") );

    RDebug::Print( _L("Mcc_COM_TEST_START: TestMultiStreamPreparingL") );

    //__UHEAP_MARK;

    TRAP( err, TestMultiStreamPreparingL() );

    //__UHEAP_MARKEND;

    RDebug::Print( _L("Mcc_COM_TEST_STOP: TestMultiStreamPreparingL, ERR: %d"), err );

    iConsole.Printf( _L("RESOURCE REUSE\n") );

    RDebug::Print( _L("Mcc_COM_TEST_START: TestResourceReuseL") );

    //__UHEAP_MARK;

    TRAP( err, TestResourceReuseL() );

    //__UHEAP_MARKEND;

    RDebug::Print( _L("Mcc_COM_TEST_STOP: TestResourceReuseL, ERR: %d"), err );

#ifndef __WINSCW__

    iConsole.Printf( _L("BASIC AUDIO STREAMING\n") );

    RDebug::Print( _L("Mcc_COM_TEST_START: TestAudioStreamingL") );

    //__UHEAP_MARK;

    TRAP( err, TestAudioStreamingL( KAMRSdpName ) );

    RDebug::Print( _L("AMR: %d"), err );

    TRAP( err, TestAudioStreamingL( KILBCSdpName ) );

    RDebug::Print( _L("iLBC: %d"), err );

    TRAP( err, TestAudioStreamingL( KPCMUSdpName ) );

    RDebug::Print( _L("PCMU: %d"), err );

    TRAP( err, TestAudioStreamingL( KPCMASdpName ) );

    RDebug::Print( _L("PCMA: %d"), err );

    TRAP( err, TestAudioStreamingL( KG729SdpName ) );

    RDebug::Print( _L("G729: %d"), err );

    //__UHEAP_MARKEND;

    RDebug::Print( _L("Mcc_COM_TEST_STOP: TestAudioStreamingL, ERR: %d"), err );

    iConsole.Printf( _L("UP/DOWNLINK PAUSE\n") );

    RDebug::Print( _L("Mcc_COM_TEST_START: TestMultiStreamPausingL") );

    //__UHEAP_MARK;

    TRAP( err, TestMultiStreamPausingL() );

    //__UHEAP_MARKEND;

    RDebug::Print( _L("Mcc_COM_TEST_STOP: TestMultiStreamPausingL, ERR: %d"), err );

    iConsole.Printf( _L("AMR-NB FEC\n") );

    RDebug::Print( _L("Mcc_COM_TEST_START: TestAmrFecL") );

    //__UHEAP_MARK;

    TRAP( err, TestAmrFecL() );

    //__UHEAP_MARKEND;

    RDebug::Print( _L("Mcc_COM_TEST_STOP: TestAmrFecL, ERR: %d"), err );

    iConsole.Printf( _L("2198 REDUNDANCY\n") );

    RDebug::Print( _L("Mcc_COM_TEST_START: TestRedundancyL") );

    //__UHEAP_MARK;

    TRAP( err, TestRedundancyL( KAMRSdpName ) );

    RDebug::Print( _L("AMR RED: %d"), err );

    TRAP( err, TestRedundancyL( KPCMASdpName ) );

    RDebug::Print( _L("PCMU RED: %d"), err );

    TRAP( err, TestRedundancyL( KPCMUSdpName ) );

    RDebug::Print( _L("PCMU RED: %d"), err );

    TRAP( err, TestRedundancyL( KILBCSdpName ) );

    RDebug::Print( _L("iLBC RED: %d"), err );

    TRAP( err, TestRedundancyL( KG729SdpName ) );

    RDebug::Print( _L("G729: %d"), err );

    //__UHEAP_MARKEND;

    RDebug::Print( _L("Mcc_COM_TEST_STOP: TestRedundancyL, ERR: %d"), err );

    iConsole.Printf( _L("AUDIO ROUTING\n") );

    RDebug::Print( _L("Mcc_COM_TEST_START: TestAudioRoutingL") );

    //__UHEAP_MARK;

    //TRAP( err, TestAudioRoutingL() );

    //__UHEAP_MARKEND;

    RDebug::Print( _L("Mcc_COM_TEST_STOP: TestAudioRoutingL, ERR: %d"), err );

#endif

    }

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

// CTestInterface::TestGetCapabilitiesL

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

//

void CTestInterface::TestGetCapabilitiesL() const

    {

    RDebug::Print( _L("CTestInterface::TestGetCapabilitiesL") );

    RPointerArray<CMccCodecInformation> codecArray;

    CleanupResetAndDestroy< RPointerArray<CMccCodecInformation> >::PushL( codecArray );

    User::LeaveIfError( iInterface.GetCapabilities( codecArray ) );

    if ( 0 == codecArray.Count() )

        {

        RDebug::Print( _L("CTestInterface::TestGetCapabilitiesL - KErrUnknown") );

        User::Leave( KErrUnknown );

        }

    CleanupStack::PopAndDestroy( &codecArray );

    }

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

// CTestInterface::TestSingleSessionCreationL

// Test explicit/implicit session creation and destruction.

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

//

void CTestInterface::TestSingleSessionCreationL()

    {

    RDebug::Print( _L("CTestInterface::TestSingleSessionCreationL") );

    TUint32 sessionId1;

    User::LeaveIfError( iInterface.CreateSession( sessionId1 ) );

    User::LeaveIfError( iInterface.CloseSession( sessionId1 ) );

    TUint32 sessionId2;

    User::LeaveIfError( iInterface.CreateSession( sessionId2 ) );

    if ( KErrNone == iInterface.CloseSession( 0 ) )

        {

        RDebug::Print( _L("CTestInterface::TestSingleSessionCreationL - KErrUnknown") );

        User::Leave( KErrUnknown );

        }

    User::LeaveIfError( iInterface.CloseSession( sessionId2 ) );

    }

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

// CTestInterface::TestSingleLinkCreationL

// 

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

//

void CTestInterface::TestSingleLinkCreationL()

    {

    RDebug::Print( _L("CTestInterface::TestSingleLinkCreationL") );

    TUint32 sessionId;

    User::LeaveIfError( iInterface.CreateSession( sessionId ) );

    RDebug::Print( _L("CTestInterface::TestSingleLinkCreationL KMccLinkGeneral") );

    TUint32 linkId1;

    User::LeaveIfError(

        iInterface.CreateLink( sessionId, KMccLinkGeneral, linkId1,

            iNetsettings ) );

    iIfStub.WaitForEvent( sessionId, linkId1, 0, KMccLinkCreated );

    User::LeaveIfError( iInterface.CloseLink( sessionId, linkId1 ) );

    RDebug::Print( _L( "CTestInterface::TestSingleLinkCreationL KMccLinkLocal" ) );

    TUint32 linkId2;

    User::LeaveIfError(

        iInterface.CreateLink( sessionId, KMccLinkLocal, linkId2,

            iNetsettings ) );

    iIfStub.WaitForEvent( sessionId, linkId2, 0, KMccLinkCreated );

    User::LeaveIfError( iInterface.CloseLink( sessionId, linkId2 ) );

    TInt err

        = iInterface.CreateLink( sessionId + 10, KMccLinkLocal, linkId2, iNetsettings );

    if ( KErrNotFound != err )

        {

        User::Leave( KErrTotalLossOfPrecision );

        }

    TUint32 linkId3;

    User::LeaveIfError(

        iInterface.CreateLink( sessionId, KMccLinkGeneral, linkId3,

            iNetsettings ) );

    iIfStub.WaitForEvent( sessionId, linkId3, 0, KMccLinkCreated );

    if ( KErrNone == iInterface.CloseLink( 0, 0 ) )

        {

        RDebug::Print( _L("CTestInterface::TestSingleLinkCreationL - KErrUnknown 1") );

        User::Leave( KErrUnknown );

        }

    if ( KErrNone == iInterface.CloseLink( sessionId, 0 ) )

        {

        RDebug::Print( _L("CTestInterface::TestSingleLinkCreationL - KErrUnknown 2") );

        User::Leave( KErrUnknown );

        }

    User::LeaveIfError( iInterface.CloseLink( sessionId, linkId3 ) );

    User::LeaveIfError( iInterface.CloseSession( sessionId ) );

    }

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

// CTestInterface::TestSingleStreamCreationL

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

//

void CTestInterface::TestSingleStreamCreationL()

    {

    TUint32 sessionId;

    User::LeaveIfError( iInterface.CreateSession( sessionId ) );

    RDebug::Print( _L( "CTestInterface::TestSingleStreamCreationL KMccLinkGeneral" ) );

    TUint32 linkId;

    User::LeaveIfError(

        iInterface.CreateLink( sessionId, KMccLinkGeneral, linkId,

            iNetsettings ) );

    iIfStub.WaitForEvent( sessionId, linkId, 0, KMccLinkCreated );

    // AUDIO UPLINK STREAM CREATION

    RDebug::Print( _L("CTestInterface::TestSingleStreamCreationL ADD RSC AUDIO UL") );

    TUint32 rtpSinkId;

    TUint32 audioSourceId;

    User::LeaveIfError(

        iInterface.AddDataSink( KMccRtpSinkUid, KNullDesC8, rtpSinkId ) );

    User::LeaveIfError(

        iInterface.AddDataSource( KUidMmfAudioInput, KNullDesC8, audioSourceId ) );

    RDebug::Print( _L("CTestInterface::TestSingleStreamCreationL CREATE AUDIO UL") );

    TUint32 streamId1;

    CMccCodecInformation* codec

        = FetchCodecByMimeSubtypeNameL( iInterface, KAMRSdpName );

    CleanupStack::PushL( codec );

    User::LeaveIfError( iInterface.CreateStream( sessionId, linkId, streamId1, 

        KMccAudioUplinkStream, *codec ) );

    User::LeaveIfError( iInterface.DeleteStream( sessionId, linkId, streamId1 ) );

    iInterface.RemoveDataSource( sessionId, linkId, streamId1, audioSourceId );

    iInterface.RemoveDataSink( sessionId, linkId, streamId1, rtpSinkId );

    // AUDIO DOWNLINK STREAM CREATION

    RDebug::Print( _L("CTestInterface::TestSingleStreamCreationL ADD RSC AUDIO DL") );

    TUint32 audioSinkId;

    TUint32 rtpSourceId;

    User::LeaveIfError(

        iInterface.AddDataSink( KUidMmfAudioOutput, KNullDesC8, audioSinkId ) );

    User::LeaveIfError(

        iInterface.AddDataSource( KMccRtpSourceUid, KNullDesC8, rtpSourceId ) );

    RDebug::Print( _L("CTestInterface::TestSingleStreamCreationL CREATE AUDIO DL") );

    TUint32 streamId2;

    User::LeaveIfError( iInterface.CreateStream( sessionId, linkId, streamId2, 

        KMccAudioDownlinkStream, *codec ) );

    User::LeaveIfError( iInterface.DeleteStream( sessionId, linkId, streamId2 ) );

    iInterface.RemoveDataSink( sessionId, linkId, streamId2, audioSinkId );

    iInterface.RemoveDataSource( sessionId, linkId, streamId2, rtpSourceId );

    // AUDIO LOCAL STREAM CREATION

    // AUDIO DOWNLINK STANDBY STREAM CREATION

    // VIDEO UPLINK STREAM CREATION

    // VIDEO DOWNLINK STREAM CREATION

    // VIDEO LOCAL STREAM CREATION

    User::LeaveIfError( iInterface.CloseLink( sessionId, linkId ) );

    User::LeaveIfError( iInterface.CloseSession( sessionId ) );

    CleanupStack::PopAndDestroy( codec );

    }

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

// CTestInterface::TestSingleStreamPreparingL

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

//

void CTestInterface::TestSingleStreamPreparingL( TInt aLinkType,

    TInt aStreamType, TUid aDataSource, TUid aDataSink, const TDesC8& aCodec )

    {

    TUint32 sessionId;

    User::LeaveIfError( iInterface.CreateSession( sessionId ) );

    TUint32 linkId;

    User::LeaveIfError(

        iInterface.CreateLink( sessionId, aLinkType, linkId, iNetsettings ) );

    iIfStub.WaitForEvent( sessionId, linkId, 0, KMccLinkCreated );

    // STREAM PREPARING, IMPLICIT ENDPOINT PREPARE

    RDebug::Print( _L( "CTestInterface::TestSingleStreamPreparingL AUDIO UL, CODEC: %S" ), &aCodec );

    TUint32 dataSinkId1;

    TUint32 dataSourceId1;

    User::LeaveIfError(

        iInterface.AddDataSink( aDataSink, KNullDesC8, dataSinkId1 ) );

    User::LeaveIfError(

        iInterface.AddDataSource( aDataSource, KNullDesC8, dataSourceId1 ) );

    TUint32 streamId1;

    CMccCodecInformation* codec

        = FetchCodecByMimeSubtypeNameL( iInterface, aCodec );

    CleanupStack::PushL( codec );