/*

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

*

*/

//*******************************************************************************

// Method      : 

// Purpose     : Working as a stub for CMccInterface instantation tests

// Parameters  : 

// Return Value: 

//*******************************************************************************

#include <e32base.h>

#include <e32debug.h>

#include <mmccinterface.h>

#include <mmccevents.h>

#include "multiplexerudptests.h"

#include "muxtestconsolestubs.h"

#include "mmccnetworksettings.h"

#include "ncmconnectionmultiplexerlogs.h"

_LIT16( KPanicArgument, "invalid argument" ); 

CMuxTestConsoleStubs* CMuxTestConsoleStubs::NewL( )

    {

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

    return self;

    }

CMuxTestConsoleStubs::CMuxTestConsoleStubs()

    {

    }

CMuxTestConsoleStubs::~CMuxTestConsoleStubs()

    {

    }

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

// CMuxTestConsoleStubs::

// 

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

//

void CMuxTestConsoleStubs::MccEventReceived( const TMccEvent& aEvent )

    {

    TMccNetSettingsPackage package;

    package.Copy( aEvent.iEventData );

    TBuf<50> localAddr;

    TBuf<50> localPublicAddr;

    iNetsettings = package();

    RDebug::Print( _L("CMuxTestConsoleStubs::MccEventReceived") );

    if ( KMccLinkCreated == aEvent.iEventType )

        {

        CActiveScheduler::Stop();

        }

    }

void CMuxTestConsoleStubs::MccMediaStarted( TUint32 aSessionId,

                                       TUint32 aLinkId,

                                       TUint32 aStreamId,

                                       TUint32 aSinkSourceId )

    {

    RDebug::Print( _L("CMuxTestConsoleStubs::MccMediaStarted") );

    RDebug::Print( _L("SESSID: %u, LINKID: %u, STREAMID: %u, SINKSOURCEID: %u"),

         aSessionId, aLinkId, aStreamId, aSinkSourceId );

     CActiveScheduler::Stop();   

    }

void CMuxTestConsoleStubs::MccMediaStopped( TUint32 aSessionId,

                                       TUint32 aLinkId,

                                       TUint32 aStreamId,

                                       TUint32 aSinkSourceId )

    {

    RDebug::Print( _L("CMuxTestConsoleStubs::MccMediaStopped") );

    RDebug::Print( _L("SESSID: %u, LINKID: %u, STREAMID: %u, SINKSOURCEID: %u"),

         aSessionId, aLinkId, aStreamId, aSinkSourceId );

    TMccEvent event = TMccEvent( aSessionId, aLinkId, aStreamId, aSinkSourceId,

        KMccEventCategoryStream, KMccStreamStopped, KErrNone, KNullDesC8 );

    }

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

// CMuxTestConsoleStubs::

// 

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

//

void CMuxTestConsoleStubs::MccMediaPaused( TUint32 aSessionId,

                                      TUint32 aLinkId,

                                      TUint32 aStreamId,

                                      TUint32 aSinkSourceId )

    {

    RDebug::Print( _L("CMuxTestConsoleStubs::MccMediaPaused") );

    RDebug::Print( _L("SESSID: %u, LINKID: %u, STREAMID: %u, SINKSOURCEID: %u"),

         aSessionId, aLinkId, aStreamId, aSinkSourceId );

    TMccEvent event = TMccEvent( aSessionId, aLinkId, aStreamId, aSinkSourceId,

        KMccEventCategoryStream, KMccStreamPaused, KErrNone, KNullDesC8 );

    }

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

// CMuxTestConsoleStubs::

// 

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

//

void CMuxTestConsoleStubs::MccMediaResumed( TUint32 aSessionId,

                                       TUint32 aLinkId,

                                       TUint32 aStreamId,

                                       TUint32 aSinkSourceId )

    {

    RDebug::Print( _L("CMuxTestConsoleStubs::MccMediaResumed") );

    RDebug::Print( _L("SESSID: %u, LINKID: %u, STREAMID: %u, SINKSOURCEID: %u"),

         aSessionId, aLinkId, aStreamId, aSinkSourceId );

    TMccEvent event = TMccEvent( aSessionId, aLinkId, aStreamId, aSinkSourceId,

        KMccEventCategoryStream, KMccStreamResumed, KErrNone, KNullDesC8 );

    }

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

// CMuxTestConsoleStubs::

// 

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

//

void CMuxTestConsoleStubs::MccMediaPrepared( TUint32 aSessionId,

                                        TUint32 aLinkId,

                                        TUint32 aStreamId,

                                        TUint32 aSinkSourceId )

    {

    RDebug::Print( _L("CMuxTestConsoleStubs::MccMediaPrepared") );

    RDebug::Print( _L("SESSID: %u, LINKID: %u, STREAMID: %u, SINKSOURCEID: %u"),

         aSessionId, aLinkId, aStreamId, aSinkSourceId );

    TMccEvent event = TMccEvent( aSessionId, aLinkId, aStreamId, aSinkSourceId,

        KMccEventCategoryStream, KMccStreamPrepared, KErrNone, KNullDesC8 );

    CActiveScheduler::Stop();

    }

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

// CMuxTestConsoleStubs::

// 

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

//

void CMuxTestConsoleStubs::MccMediaInactive( TUint32 aSessionId,

                                        TUint32 aLinkId,

                                        TUint32 aStreamId,

                                        TUint32 aSinkSourceId )

    {

    RDebug::Print( _L("CMuxTestConsoleStubs::MccMediaInactive" ) );

    RDebug::Print( _L("SESSID: %u, LINKID: %u, STREAMID: %u, SINKSOURCEID: %u"),

         aSessionId, aLinkId, aStreamId, aSinkSourceId );

    TMccEvent event = TMccEvent( aSessionId, aLinkId, aStreamId, aSinkSourceId,

        KMccEventCategoryRtp, KMccInactivityEvent, KErrNone, KNullDesC8 );

    }

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

// CMuxTestConsoleStubs::

// 

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

//

void CMuxTestConsoleStubs::MccMediaActive( TUint32 aSessionId,

                                      TUint32 aLinkId,

                                      TUint32 aStreamId,

                                      TUint32 aSinkSourceId )

    {

    RDebug::Print( _L("CMuxTestConsoleStubs::MccMediaActive") );

    RDebug::Print( _L("SESSID: %u, LINKID: %u, STREAMID: %u, SINKSOURCEID: %u"),

         aSessionId, aLinkId, aStreamId, aSinkSourceId );

    TMccEvent event = TMccEvent( aSessionId, aLinkId, aStreamId, aSinkSourceId,

        KMccEventCategoryRtp, KMccActivityEvent, KErrNone, KNullDesC8 );

    }

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

// CMuxTestConsoleStubs::

// 

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

//

void CMuxTestConsoleStubs::MccCtrlError( TInt aError,

                                      TUint32 aSessionId,

                                      TUint32 aLinkId,

                                      TUint32 aStreamId,

                                      TUint32 aSinkSourceId )

    {

    RDebug::Print( _L("CMuxTestConsoleStubs::MccCtrlError, ERR: %d"), aError );

    RDebug::Print( _L("SESSID: %u, LINKID: %u, STREAMID: %u, SINKSOURCEID: %u"),

         aSessionId, aLinkId, aStreamId, aSinkSourceId );

    TMccEvent event = TMccEvent( aSessionId, aLinkId, aStreamId, aSinkSourceId,

        KMccEventCategoryStream, KMccStreamError, aError, KNullDesC8 );

    }

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

// CMuxTestConsoleStubs::

// 

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

//

void CMuxTestConsoleStubs::UnknownMediaReceived( TUint32 aSessionId,

                                              TUint32 /*aLinkId*/,  

                                              TUint32 aStreamId,

                                              TUint32 /*aSinkSourceId*/,

                                              TUint8 aPayloadType )

    {

    RDebug::Print( _L("CMuxTestConsoleStubs::UnknownMediaReceived") );

    RDebug::Print( _L("SESSID: %u, STREAMID: %u, PT: %u"),

     aSessionId, aStreamId, aPayloadType );

    } 

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

// CMuxTestConsoleStubs::StreamNotify

// 

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

//

void CMuxTestConsoleStubs::Notify( TUint aSessionId, TUint aStreamId,

    TNotifyType aType, TInt aError )

    {

    RDebug::Print( _L("CMuxTestConsoleStubs::Notify") );

    RDebug::Print( _L("aStreamId ID: %u, aStreamId ID: %u , ERROR: %d "), aSessionId, aStreamId, aError );

    // All test must notify with error code KErrNone

    ASSERT( KErrNone == aError || KErrDisconnected == aError );

    if ( MNcmConnectionMultiplexerObserver::ESessionCreated  == aType )

        {

        RDebug::Print( _L("Notify   -    ESessionCreated") );

        CActiveScheduler::Stop();

        }

    if ( MNcmConnectionMultiplexerObserver::EReceivingActivated  == aType )

        {

        RDebug::Print( _L("Notify   -    EReceivingActivated") );

        CActiveScheduler::Stop();  

        }

    if ( MNcmConnectionMultiplexerObserver::EReceivingDeactivated  == aType )

        {

        RDebug::Print( _L("Notify   -    EReceivingDeactivated") );

        CActiveScheduler::Stop();

        } 

    if ( MNcmConnectionMultiplexerObserver::ESendingActivated  == aType )

        {

        RDebug::Print( _L("Notify   -    ESendingActivated") );

        CActiveScheduler::Stop();

        }

    if ( MNcmConnectionMultiplexerObserver::ESendingDeactivated  == aType )

        {

        RDebug::Print( _L("Notify   -    ESendingDeActivated") );

        CActiveScheduler::Stop();

        }

    if ( MNcmConnectionMultiplexerObserver::EStreamError  == aType )

        {

        RDebug::Print( _L("Notify   -    EStreamError") );

        }            

    }

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

// CMuxTestConsoleStubs::IcmpError

// 

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

//

void CMuxTestConsoleStubs::IcmpError( TUint /*aSessionId*/, TUint /*aStreamId*/,

    const TInetAddr& aAddress )

    {

    RDebug::Print( _L("CMuxTestConsoleStubs::IcmpError") );

    TInetAddr fromAddr( aAddress );               

    TBuf<160> buffer3;

    fromAddr.Output( buffer3 );

    RDebug::Print( _L("CMuxTestConsoleStubs::IcmpError - ADDRESS: %S "), &buffer3 );

    }

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

// CMuxTestConsoleStubs::ClearEvent

// 

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

//

void CMuxTestConsoleStubs::ClearEvent( /*TMccEvent& aEvent*/ )

    {

    //Event = TMccEvent();

    }

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

// CMuxTestConsoleStubs::HandleEventReceival

// 

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

//

void CMuxTestConsoleStubs::HandleEventReceival( TUint /*aStreamId*/ )

    {

    /*

    if ( EventsAreEqual( iEventToWaitFor, aEvent ) )

        {

        RDebug::Print( _L("CMuxTestConsoleStubs::HandleEventReceival, STOP WAIT LOOP") );

        CActiveScheduler::Stop();

        }

    else

        {

        // Eat event and continue to listen a new one

        RDebug::Print( _L("CMuxTestConsoleStubs::HandleEventReceival, UNEXPECTED EVENT") );

        }*/

/*

        iActive = EFalse;

        CActiveScheduler::Stop();

        */

    }

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

// CMuxTestConsoleStubs::IncomingMessageL

// 

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

//

void CMuxTestConsoleStubs::IncomingMessageL(  TUint /*aStreamId*/, const TDesC8& /*aMessage*/,

        const TInetAddr& aLocalAddr, const TInetAddr& aFromAddr, const TInetAddr& aPeerRemoteAddress,

        TBool& /*aConsumed*/ )

    {

    RDebug::Print( _L("CMuxTestConsoleStubs::IncomingMessageL") );

    TInetAddr fromAddr1( aLocalAddr );               

    TBuf<160> buffer1;

    fromAddr1.Output( buffer1 );

    RDebug::Print( _L("CMuxTestConsoleStubs::IncomingMessageL - LOCAL ADDRESS: %S "), &buffer1 );

    TInetAddr fromAddr( aPeerRemoteAddress );               

    TBuf<160> buffer3;

    fromAddr.Output( buffer3 );

    RDebug::Print( _L("CMuxTestConsoleStubs::IncomingMessageL - PEER ADDRESS: %S "), &buffer3 );

    TInetAddr fromAddr2( aFromAddr );               

    TBuf<160> buffer4;

    fromAddr2.Output( buffer4 );

    RDebug::Print( _L("CMuxTestConsoleStubs::IncomingMessageL - FROM ADDRESS: %S "), &buffer4 );

    }

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

// CMuxTestConsoleStubs::IncomingMessageNotify

// 

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

//

HBufC8* CMuxTestConsoleStubs::IncomingMessageNotify( TUint /*aStreamId*/,

        const TDesC8& /*aMessage*/, const TInetAddr& /*aLocalAddr*/,

        const TInetAddr& /*aFromAddr*/, TInetAddr& /*aPeerRemoteAddr*/ )

    {

    RDebug::Print( _L("CMuxTestConsoleStubs::IncomingMessageNotify") );

    return NULL;  

    }

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

// CMuxTestConsoleStubs::OutgoingMessageNotify

// 

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

//

HBufC8* CMuxTestConsoleStubs::OutgoingMessageNotify( TUint /*aStreamId*/,

        TUint /*aConnectionId*/, const TInetAddr& aDestinationAddress,

        const TDesC8& /*aMessage*/ )

    {

    RDebug::Print( _L("CMuxTestConsoleStubs::OutgoingMessageNotify") );

    TInetAddr fromAddr1( aDestinationAddress );               

    TBuf<160> buffer1;

    fromAddr1.Output( buffer1 );

    RDebug::Print( _L("CMuxTestConsoleStubs::OutgoingMessageNotify - aDestinationAddress: %S "), &buffer1 );

    return NULL;

    }

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

// CMuxTestConsoleStubs::ConnectionNotifyL

// 

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

//

 void CMuxTestConsoleStubs::ConnectionNotify(  TUint /*aStreamId*/, TUint aConnectionId,

    MNcmConnectionObserver::TConnectionNotifyType aType, TInt aError )

    {

    RDebug::Print( _L("CMuxTestConsoleStubs::ConnectionNotifyL") );

    RDebug::Print( _L("Connection ID: %u , ERROR: %d "), aConnectionId, aError );

    // All test must notify with error code KErrNone

    ASSERT( KErrNone == aError || KErrDisconnected == aError || KErrCancel == aError );

    if ( EConnectionError == aType && KErrDisconnected == aError )

        {

        CActiveScheduler::Stop(); 

        }

    else if ( MNcmConnectionObserver::EConnectionRemoved  == aType )

        {

        RDebug::Print( _L("ConnectionNotifyL   -    EConnectionRemoved") );

        }

    else if ( MNcmConnectionObserver::EConnectionError  == aType )

        {

        RDebug::Print( _L("ConnectionNotifyL   -    EConnectionError") );

        }  

    else if ( MNcmConnectionObserver::EReceivingActivated  == aType )

        {

        RDebug::Print( _L("ConnectionNotifyL   -    EReceivingActivated") );

        CActiveScheduler::Stop();

        } 

    else if ( MNcmConnectionObserver::ESendingActivated  == aType )

        {

        RDebug::Print( _L("ConnectionNotifyL   -    ESendingActivated") );

        CActiveScheduler::Stop();

        }

    else if ( MNcmConnectionObserver::EReceivingDeactivated  == aType )

        {

        RDebug::Print( _L("ConnectionNotifyL   -    EReceivingDeactivated") );

        CActiveScheduler::Stop();

        } 

    else if ( MNcmConnectionObserver::ESendingDeactivated  == aType )

        {

        RDebug::Print( _L("ConnectionNotifyL   -    ESendingDeActivated") );

        CActiveScheduler::Stop();

        }

    else if ( MNcmConnectionObserver::ETcpConnSetupCompleted  == aType )

        {

        RDebug::Print( _L("ConnectionNotifyL   -    ETcpConnConnected") );

        CActiveScheduler::Stop();

        }

    else if ( MNcmConnectionObserver::EFirstMediaPacketSent  == aType )

        {

        RDebug::Print( _L("ConnectionNotifyL   -    EFirstMediaPacketSent") );

        CActiveScheduler::Stop();

        }

    else

        {

        RDebug::Print( _L("ConnectionNotifyL   -    default") );

        __ASSERT_ALWAYS( EFalse, User::Panic( KPanicArgument, KErrArgument ) );    

        }

    }

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

// CMuxTestConsoleStubs::OutgoingMessage

// 

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

//

void CMuxTestConsoleStubs::OutgoingMessageL( TUint /*aStreamId*/, TUint /*aConnectionId*/,

        const TInetAddr& aDestinationAddress, const TDesC8& /*aMessage*/, TBool& /*aConsumed*/ )

    {

    RDebug::Print( _L("CMuxTestConsoleStubs::OutgoingMessage") );

    TInetAddr fromAddr( aDestinationAddress );               

    TBuf<160> buffer3;

    fromAddr.Output( buffer3 );

    RDebug::Print( _L("CMuxTestConsoleStubs::OutgoingMessage - ADDRESS: %S "), &buffer3 );

    }

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

// CMuxTestConsoleStubs::WaitForEvent

// 

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

//

void CMuxTestConsoleStubs::WaitForEvent( TUint /*aStreamId*/, TUint /*aSubStreamId*/,

    MNcmConnectionObserver::TConnectionNotifyType /*aNotifyType*/ )

    {

    } 

void CMuxTestConsoleStubs::MessageSent()

    {

    RDebug::Print( _L("CMuxTestConsoleStubs::MessageSent") );

    CActiveScheduler::Stop();

    }

void CMuxTestConsoleStubs::MessageSentFailure( TInt aError )

    {

    RDebug::Print( _L("CMuxTestConsoleStubs::MessageSentFailure - error: %d"), aError );  

    }