/*

* Copyright (c) 2006-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:    Source for multiplexer, where Media Wrapper is mounted to

*

*/

#include "cncmmediasource.h"

#include "ncmconnectionmultiplexerlogs.h"

#include "mncmmediasourceobserver.h"

#include "natfwmediawrapper.h"

#include "mncmsourceobserver.h"

#include "ncmconnectionmultiplexerassert.h"

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

// CNcmMediaSource::CNcmMediaSource

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

//

CNcmMediaSource::CNcmMediaSource(

    MNcmMediaSourceObserver& aMediaObserver,

    MNATFWMediaWrapper& aMediaWrapper ) :

    iMediaObserver( aMediaObserver ),

    iMediaWrapper( aMediaWrapper ),

    iReceivingState( EStreamingStateUnknown )

    {

    __CONNECTIONMULTIPLEXER( "CNcmMediaSource::CNcmMediaSource" )

    }

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

// CNcmMediaSource::ConstructL

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

//

void CNcmMediaSource::ConstructL( const RSocketServ& aSocketServ,

    const TInetAddr& aLocalAddr )

    {

    __CONNECTIONMULTIPLEXER( "CNcmMediaSource::ConstructL" )

    iMediaWrapper.RegisterMediaWrapperObserverL( this, aSocketServ,

                                                 aLocalAddr );    

    }   

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

// CNcmMediaSource::NewL

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

//

CNcmMediaSource* CNcmMediaSource::NewL(

    MNcmMediaSourceObserver& aMediaObserver,

    MNATFWMediaWrapper& aMediaWrapper,

    const RSocketServ& aSocketServ,

    const TInetAddr& aLocalAddr )

    {

    __CONNECTIONMULTIPLEXER( "CNcmMediaSource::NewL" )

    CNcmMediaSource* self = CNcmMediaSource::NewLC(

        aMediaObserver, aMediaWrapper, aSocketServ, aLocalAddr );

    CleanupStack::Pop( self );

    return self;

    }

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

// CNcmMediaSource::NewLC

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

//

CNcmMediaSource* CNcmMediaSource::NewLC(

    MNcmMediaSourceObserver& aMediaObserver,

    MNATFWMediaWrapper& aMediaWrapper,

    const RSocketServ& aSocketServ,

    const TInetAddr& aLocalAddr )

    {

    __CONNECTIONMULTIPLEXER( "CNcmMediaSource::NewLC" )

    CNcmMediaSource* self =

        new( ELeave ) CNcmMediaSource( aMediaObserver, aMediaWrapper );

    CleanupStack::PushL( self );

    self->ConstructL( aSocketServ, aLocalAddr );

    return self;

    }

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

// CNcmMediaSource::~CNcmMediaSource

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

//

CNcmMediaSource::~CNcmMediaSource()

    {

    __CONNECTIONMULTIPLEXER( "CNcmMediaSource::~CNcmMediaSource" )

    iMessageObserver = NULL;

    }

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

// CNcmMediaSource::RegisterMessageObserver

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

//

void CNcmMediaSource::RegisterMessageObserver(

    MNcmSourceObserver& aMessageObserver )

    {

    __CONNECTIONMULTIPLEXER( "CNcmMediaSource::RegisterMessageObserver" )

    iMessageObserver = &aMessageObserver;

    }

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

// CNcmMediaSource::UnregisterMessageObserver

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

//   

void CNcmMediaSource::UnregisterMessageObserver(

    const MNcmSourceObserver& aMessageObserver )

    {

    __CONNECTIONMULTIPLEXER( "CNcmMediaSource::UnRegisterMessageObserver" )

     __CONNECTIONMULTIPLEXER_ASSERT_L(

        &aMessageObserver == iMessageObserver, KErrArgument );

    iMessageObserver = NULL;     

    }

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

// CNcmMediaSource::SetReceivingState

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

//

void CNcmMediaSource::SetReceivingState( TNATFWStreamingState aState )

    {

    __CONNECTIONMULTIPLEXER( "CNcmMediaSource::SetReceivingState" )

    iReceivingState = aState;

    }

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

// From class MMultiplexerSourceBase

//

// CNcmMediaSource::PutMessage

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

//

void CNcmMediaSource::PutMessageL( const TDesC8& aMessage )

    {

    __CONNECTIONMULTIPLEXER( "CNcmMediaSource::PutMessage" )

    if ( EStreamingStateActive == iReceivingState )

        {

        TRAP_IGNORE( iMediaWrapper.SendL( aMessage ) )

        }

    }

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

// From class MNATFWMediaWrapperObserver

//

// CNcmMediaSource::SendingCompleted

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

//

void CNcmMediaSource::SendingCompleted( TInt aError )

    {

    if ( aError )

        {

        iMediaObserver.WrapperSenderError( iMediaWrapper.StreamId(), aError );

        }

    }

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

// From class MNATFWMediaWrapperObserver

//

// CNcmMediaSource::ReceivedFrom

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

//

TInt CNcmMediaSource::ReceivedFrom( const TUint /*aStreamId*/,

    TDes8& aReceiveBuffer )

    {

    __CONNECTIONMULTIPLEXER( "CNcmMediaSource::ReceivedFrom" )

    if ( iMessageObserver )

        {

        if ( iFirstMediaPacketIsSent )

            {

            iMessageObserver->OutgoingMessageAvailable(

                aReceiveBuffer, NULL, KAFUnspec );           

            }

        else

            {

            iMessageObserver->OutgoingMessageAvailable(

                aReceiveBuffer, this, KAFUnspec );           

            }

        }

    return KErrNone;

    }

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

// From class MNATFWMediaWrapperObserver

//

// CNcmMediaSource::GetNewFreePort

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

//

void CNcmMediaSource::GetNewFreePort( TUint& aPort )

    {

    __CONNECTIONMULTIPLEXER( "CNcmMediaSource::GetNewFreePort" )

    iMediaObserver.GetFreePort( iMediaWrapper.StreamId(), aPort );

    }

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

// From class MNcmSenderObserver

//

// CNcmMediaSource::MessageSent

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

//

void CNcmMediaSource::MessageSent()

    {

    __CONNECTIONMULTIPLEXER( "CNcmMediaSource::MessageSent" )

    iFirstMediaPacketIsSent = ETrue;

    iMediaObserver.FirstMediaPacketSent( iMediaWrapper.StreamId() );

    }

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

// From class MNcmSenderObserver

//

// CNcmMediaSource::MessageSentFailure

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

//

void CNcmMediaSource::MessageSentFailure( TInt /*aError*/ )

    {

    __CONNECTIONMULTIPLEXER( "CNcmMediaSource::MessageSentFailure" )

    }