/*

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

*

*/

#include "mcemediastream.h"

#include "mcesession.h"

#include "mcemanager.h"

#include "mcestreamobserver.h"

#include "mcertpobserver.h"

#include "mcecommediastream.h"

#include "mcefactory.h"

#include "mceserial.h"

#include "mceevents.h"

#include "mceclilogs.h"

#include "mcesessionobserver.h"

#define _FLAT_DATA static_cast<CMceComMediaStream*>( iFlatData )

#define FLAT_DATA( data ) _FLAT_DATA->data

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

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

// CMceMediaStream::~CMceMediaStream

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

//

EXPORT_C CMceMediaStream::~CMceMediaStream()

    {

    MCECLI_DEBUG("CMceMediaStream::~CMceMediaStream, Entry");

    MCECLI_DEBUG_DVALUE("id", iFlatData ? Id().iId : KMceNotAssigned );

    if ( iSource )

        {

        DeleteSource();

        }

    if ( _FLAT_DATA && FLAT_DATA( iLinkOwner ) )

	    {

    	delete iLinkedStream;

	    }

	while( iSinks.Count() > 0 )

	    {

	    DeleteSink( 0 );

	    }

    iSinks.Reset();

    iSinks.Close();

    delete iFlatData;

    MCECLI_DEBUG("CMceMediaStream::~CMceMediaStream, Exit");

    }

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

// CMceMediaStream::Type

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

//

EXPORT_C TMceMediaType CMceMediaStream::Type() const

    {

    return FLAT_DATA( iType );

    }

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

// CMceMediaStream::SetMediaAttributeLinesL

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

//

EXPORT_C void CMceMediaStream::SetMediaAttributeLinesL(

    CDesC8Array* aMediaSDPLines )

    {

    MCECLI_DEBUG("CMceMediaStream::SetMediaAttributeLinesL, Entry");

    User::LeaveIfError( !iSession || 

                      ( iSession->State() == CMceSession::EIdle ||

		                iSession->State() == CMceSession::EIncoming ||

		                iSession->State() == CMceSession::EEstablished ) ? 

		                KErrNone : KErrNotReady );

    CDesC8Array* lines = NULL;

    TBool linesPushed = EFalse;

    if ( aMediaSDPLines )

        {

        lines = aMediaSDPLines;

        }

    else

        {

        lines = new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity );

        CleanupStack::PushL( lines );

        linesPushed = ETrue;

        }

    if ( iLinkedStream )

        {

        CDesC8Array* copyLines = 

            new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity );

        CleanupStack::PushL( copyLines );

        for ( TInt i = 0; i < lines->MdcaCount(); i++ )

            {

            copyLines->AppendL( lines->MdcaPoint( i ) );

            }

        delete iLinkedStream->iFlatData->iLocalMediaSDPLines;

        iLinkedStream->iFlatData->iLocalMediaSDPLines = copyLines;

        CleanupStack::Pop( copyLines );

        }

    if ( linesPushed )

        {

        CleanupStack::Pop( lines );

        }

    delete FLAT_DATA( iLocalMediaSDPLines );

    FLAT_DATA( iLocalMediaSDPLines ) = lines;

    MCECLI_DEBUG("CMceMediaStream::SetMediaAttributeLinesL, Exit");

    }

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

// CMceMediaStream::MediaAttributeLinesL

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

//

EXPORT_C MDesC8Array* CMceMediaStream::MediaAttributeLinesL()

    {

    CDesC8Array*  lines = new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity );

    CleanupStack::PushL( lines );

    for ( TInt i=0; i < FLAT_DATA( iRemoteMediaSDPLines )->Count(); i++ )

        {

        lines->AppendL( FLAT_DATA( iRemoteMediaSDPLines )->MdcaPoint( i ) );

        }

    CleanupStack::Pop( lines );

    return lines;

    }

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

// CMceMediaStream::SetStartMediaPort

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

//

EXPORT_C void CMceMediaStream::SetLocalMediaPortL( TUint aLocalMediaPort )

    {

    MCECLI_DEBUG("CMceMediaStream::SetLocalMediaPortL, Entry");

    MCECLI_DEBUG_DVALUE("port", aLocalMediaPort );

    FLAT_DATA( iLocalMediaPort ) = aLocalMediaPort;

    MCECLI_DEBUG("CMceMediaStream::SetLocalMediaPortL, Exit");

    }

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

// CMceMediaStream::StartMediaPort

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

//

EXPORT_C TUint CMceMediaStream::LocalMediaPort() const        

    {

    return FLAT_DATA( iLocalMediaPort );

    }

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

// CMceMediaStream::Session

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

//

EXPORT_C CMceSession* CMceMediaStream::Session() const

    {

    return iSession;

    }

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

// CMceMediaStream::EnableL

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

//

void CMceMediaStream::EnableL() 

    {

    MCECLI_DEBUG("CMceMediaStream::EnableL, Entry");

    if ( iSource )

        {

    	iSource->Enabled( ETrue );

        }

    for ( TInt i = 0; i < iSinks.Count(); i++ )

        {

        iSinks[ i ]->Enabled( ETrue );

        }

    FLAT_DATA( iIsEnabled ) = ETrue;

    MCECLI_DEBUG("CMceMediaStream::EnableL, Exit");

    }

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

// CMceMediaStream::DisableL

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

//

void CMceMediaStream::DisableL() 

    {

    MCECLI_DEBUG("CMceMediaStream::DisableL, Entry");

    if ( iSource )

        {

    	iSource->Enabled( EFalse );

        }

    for ( TInt i = 0; i < iSinks.Count(); i++ )

        {

        iSinks[ i ]->Enabled( EFalse );

        }

    FLAT_DATA( iIsEnabled ) = EFalse;

    MCECLI_DEBUG("CMceMediaStream::DisableL, Exit");

    }

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

// CMceMediaStream::IsEnabled

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

//

EXPORT_C TBool CMceMediaStream::IsEnabled() const

    {

    return FLAT_DATA( iIsEnabled );

    }

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

// CMceMediaStream::SetSourceL

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

//

EXPORT_C void CMceMediaStream::SetSourceL( CMceMediaSource* aSource )

    {

    if ( aSource )

        {

        aSource->ReferenceCount()++;

        }

    if ( iSource )

        {

        DeleteSource();

        }

    iSource = aSource;

    }

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

// CMceMediaStream::AddSinkL

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

//

EXPORT_C void CMceMediaStream::AddSinkL( CMceMediaSink* aSink )

    {

    __ASSERT_ALWAYS( aSink, User::Leave( KErrArgument ) );

    __ASSERT_ALWAYS( iSinks.Count() == 0, User::Leave( KErrNotSupported ) );

    iSinks.AppendL( aSink );

    aSink->ReferenceCount()++;    

    }

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

// CMceMediaStream::Source

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

//

EXPORT_C CMceMediaSource* CMceMediaStream::Source() const

    {

    return iSource;

    }

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

// CMceMediaStream::Sinks

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

//

EXPORT_C const RPointerArray<CMceMediaSink>& CMceMediaStream::Sinks() const

    {

    return iSinks;

    }

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

// CMceMediaStream::RemoveSinkL

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

//

EXPORT_C void CMceMediaStream::RemoveSinkL( CMceMediaSink& aSink )

    {

	for ( TInt i = 0; i < iSinks.Count(); i++ )

	    {

	    if ( iSinks[i] == &aSink )

	        {

	        DeleteSink( i );

	        iSinks.Compress();

	        return;

	        }

	    }

	User::Leave( KErrNotFound );

    }

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

// CMceMediaStream::BindL

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

//

EXPORT_C void CMceMediaStream::BindL( CMceMediaStream* aStream )

    {

    __ASSERT_ALWAYS( !(! FLAT_DATA( iLinkOwner ) &&  

                         FLAT_DATA( iLinkedStream ) ) , 

                         User::Leave( KErrArgument ) );

    if ( aStream )

        {

        FLAT_DATA(iLinkOwner) = ETrue;

        aStream->DoBindL( this );

        DoBindL( aStream );

        }

    else

        {

        FLAT_DATA(iLinkOwner) = EFalse;

    	delete iLinkedStream;

    	iLinkedStream = NULL;

        }

    }

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

// CMceMediaStream::BoundStreamL

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

//

EXPORT_C CMceMediaStream& CMceMediaStream::BoundStreamL() const

    {

    __ASSERT_ALWAYS( iLinkedStream , User::Leave( KErrNotFound ) );

    return *iLinkedStream;

    }

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

// CMceMediaStream::BoundStream

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

//

EXPORT_C TBool CMceMediaStream::BoundStream() const

    {

    return iLinkedStream != NULL;

    }

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

// CMceMediaStream::State

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

//

EXPORT_C CMceMediaStream::TState CMceMediaStream::State() const

    {

    return FLAT_DATA( iState );

    }

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

// CMceMediaStream::InternalizeFlatL

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

//

void CMceMediaStream::InternalizeFlatL( RReadStream& aReadStream )

    {

    __ASSERT_ALWAYS( iFlatData , User::Leave( KErrNotReady ) );

    _FLAT_DATA->InternalizeFlatL( aReadStream );

    }

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

// CMceMediaStream::ExternalizeFlatL

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

//

void CMceMediaStream::ExternalizeFlatL( RWriteStream& aWriteStream )

    {

    __ASSERT_ALWAYS( iFlatData , User::Leave( KErrNotReady ) );

    _FLAT_DATA->ExternalizeFlatL( aWriteStream );

    }

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

// CMceMediaStream::SerializationId

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

//

TUint64 CMceMediaStream::SerializationId() const

    {

    return FLAT_DATA( SerializationId() );

    }

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

// CMceMediaStream::InternalizeL

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

//

void CMceMediaStream::InternalizeL( MMceComSerializationContext& aSerCtx )

    {

    TMceMediaStreamSerializer<CMceMediaStream> serial( *this, _FLAT_DATA );

    serial.InternalizeL( aSerCtx );

    }

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

// CMceMediaStream::ExternalizeL

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

//

void CMceMediaStream::ExternalizeL( MMceComSerializationContext& aSerCtx )

    {

    TMceMediaStreamSerializer<CMceMediaStream> serial( *this, _FLAT_DATA );

    serial.ExternalizeL( aSerCtx );

    }

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

// CMceMediaStream::SetSourceL

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

//

void CMceMediaStream::SetSourceL( MMceComSerializationContext& aSerCtx )

    {

    RReadStream& readStream = aSerCtx.ReadStream();

    TBool externalizedReference = readStream.ReadUint8L();

    if ( externalizedReference )

        {        

        TMceMediaId id;

        MceSerial::DecodeL( id, readStream );

        CMceMediaSource* source = NULL;

        TInt index = 0;

        MCECLI_DEBUG_DVALUE("CMceMediaStream::SetSourceL, using cached source. id", id.iId );

        while( !source && index < aSerCtx.SourceCache().Count() )

            {

            source = static_cast<CMceMediaSource*>( aSerCtx.SourceCache()[ index++ ] );

            source = source->SerializationId() == id.Uint64() ? source : NULL;

            }

        __ASSERT_ALWAYS( source, User::Leave( KErrNotFound ) );

        SetSourceL( source );

        }

    else

        {

        CMceMediaSource* source = 

            BaseFactory().SourceFactory().CreateLC( aSerCtx );

        SetSourceL( source );

        CleanupStack::Pop( source );

        aSerCtx.SourceCache().AppendL( source );

        }

    }

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

// CMceMediaStream::AddSinkL

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

//

void CMceMediaStream::AddSinkL( MMceComSerializationContext& aSerCtx )

    {

    RReadStream& readStream = aSerCtx.ReadStream();

    TBool externalizedReference = readStream.ReadUint8L();

    if ( externalizedReference )

        {

        TMceMediaId id;

        MceSerial::DecodeL( id, readStream );

        CMceMediaSink* sink = NULL;

        TInt index = 0;

        MCECLI_DEBUG_DVALUE("CMceMediaStream::AddSinkL, using cached sink. id", id.iId );

        while( !sink && index < aSerCtx.SinkCache().Count() )

            {

            sink = static_cast<CMceMediaSink*>( aSerCtx.SinkCache()[ index++ ] );

            sink = sink->SerializationId() == id.Uint64() ? sink : NULL;

            }

        __ASSERT_ALWAYS( sink, User::Leave( KErrNotFound ) );

        AddSinkL( sink );

        }

    else

        {

        CMceMediaSink* sink = 

            BaseFactory().SinkFactory().CreateLC( aSerCtx );

        AddSinkL( sink );

        CleanupStack::Pop( sink );

        aSerCtx.SinkCache().AppendL( sink );

        }

    }

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

// CMceMediaStream::BaseFactory

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

//

TMceFactory CMceMediaStream::BaseFactory() const

    {

    return TMceFactory();

    }

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

// CMceMediaStream::Factory

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

//

TMceMediaStreamFactory CMceMediaStream::Factory()

    {

    return TMceMediaStreamFactory();

    }

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

// CMceMediaStream::Binder

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

//

TBool CMceMediaStream::Binder() const

    {

    return _FLAT_DATA->Binder();

    }