/*

* 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 "mcestreambundle.h"

#include "mcesession.h"

#include "mcecomstreambundle.h"

#include "mcefactory.h"

#include "mceserial.h"

#include "mceendpointproxy.h"

#define _FLAT_DATA static_cast<CMceComStreamBundle*>( iFlatData )

#define FLAT_DATA( data ) _FLAT_DATA->data

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

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

// CMceStreamBundle::NewL

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

//

EXPORT_C CMceStreamBundle* CMceStreamBundle::NewL( TMceStreamBundleType aType )

    {

    CMceStreamBundle* self = NewLC( aType );

    CleanupStack::Pop( self );

    return self;   

    }

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

// CMceStreamBundle::NewLC

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

//

EXPORT_C CMceStreamBundle* CMceStreamBundle::NewLC( TMceStreamBundleType aType )

    {

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

    CleanupStack::PushL( self );

    self->ConstructL( aType );

    return self;

    }

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

// CMceStreamBundle::~CMceStreamBundle

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

//

EXPORT_C CMceStreamBundle::~CMceStreamBundle()

    {

    delete iFlatData;

    iStreams.Close();

    iTempStreams.Close();

    }

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

// CMceStreamBundle::Type

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

//

EXPORT_C CMceStreamBundle::TMceStreamBundleType CMceStreamBundle::Type() const

    {

    return FLAT_DATA( Type() );

    }

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

// CMceStreamBundle::AddStreamL

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

//

EXPORT_C void CMceStreamBundle::AddStreamL( CMceMediaStream& aStream )

    {

    iStreams.AppendL( &aStream );

    }

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

// CMceStreamBundle::RemoveStreamL

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

//

EXPORT_C void CMceStreamBundle::RemoveStreamL( CMceMediaStream& aStream )

    {

    TInt index = iStreams.Find( &aStream );

    User::LeaveIfError( index );

    iStreams.Remove( index );

    }

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

// CMceStreamBundle::Streams

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

//

EXPORT_C const RPointerArray< CMceMediaStream >& CMceStreamBundle::Streams()

    {

    return iStreams;

    }

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

// CMceStreamBundle::SerializationId

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

//

TUint64 CMceStreamBundle::SerializationId() const

    {

    return FLAT_DATA( SerializationId() );

    }

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

// CMceStreamBundle::InternalizeFlatL

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

//

void CMceStreamBundle::InternalizeFlatL( RReadStream& aReadStream )

    {

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

    _FLAT_DATA->InternalizeFlatL( aReadStream );

    }

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

// CMceStreamBundle::ExternalizeFlatL

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

//

void CMceStreamBundle::ExternalizeFlatL( RWriteStream& aWriteStream )

    {

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

    _FLAT_DATA->ExternalizeFlatL( aWriteStream );

    }

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

// CMceStreamBundle::InternalizeL

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

//

void CMceStreamBundle::InternalizeL( MMceComSerializationContext& aSerCtx )

    {

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

    RReadStream& readStream = aSerCtx.ReadStream();

    InternalizeFlatL( readStream );

    TUint32 i = 0;

    TInt j = 0;

    TMceMediaId streamId;

    TUint32 streamCount = readStream.ReadUint32L();

    for( i = 0; i<streamCount; i++)

        {

        MceSerial::DecodeL( streamId, readStream );

        for( j = 0; j < iSession->Streams().Count();j++ )

            {

            CMceMediaStream* stream = iSession->Streams()[ j ];

            if ( stream->Id() == streamId )

                {

                AddStreamL( *stream );

                }

            }

        }

    }

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

// CMceStreamBundle::ExternalizeL

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

//

void CMceStreamBundle::ExternalizeL( MMceComSerializationContext& aSerCtx )

    {

    RWriteStream& writeStream = aSerCtx.WriteStream();

    ExternalizeFlatL( writeStream );

	writeStream.WriteUint32L( iStreams.Count() );

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

	    {

        MceSerial::EncodeL( iStreams[ i ]->Id(), writeStream );

    	}

    }

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

// CMceStreamBundle::AddedL

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

//

void CMceStreamBundle::AddedL()

    {

    MMceEndPointProxy* proxy = NULL;

    CMceMediaSink* endpoint = NULL;

    TInt i = 0;

    //sinks

    for( i = 0; i< iStreams.Count(); i++ )

        {

        CMceMediaStream* stream = iStreams[ i ];

        AddedSinkL( *stream, endpoint, proxy );

        if ( stream->BoundStream() )

            {

            AddedSinkL( stream->BoundStreamL(), endpoint, proxy );

            }

        }

    }

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

// CMceStreamBundle::AddedSinkL

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

//

void CMceStreamBundle::AddedSinkL( CMceMediaStream& aStream,

                                   CMceMediaSink*& aCurrentSink,

                                   MMceEndPointProxy*& aProxy )

    {

    for( TInt j=0; j < aStream.Sinks().Count(); j++ )

        {

        aProxy = aCurrentSink ? aCurrentSink->EndpointProxy() : aProxy;

        aCurrentSink = aStream.Sinks()[ j ];

        aCurrentSink->SetupEndpointProxyL( aProxy );

        }

    }

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

// CMceStreamBundle::InitializeL

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

//

void CMceStreamBundle::InitializeL( CMceSession& aParent )

    {

    iSession = &aParent;

    }

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

// CMceStreamBundle::CMceStreamBundle

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

//

CMceStreamBundle::CMceStreamBundle()

    {

    }

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

// CMceStreamBundle::ConstructL

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

//

void CMceStreamBundle::ConstructL( CMceStreamBundle::TMceStreamBundleType aType )

    {

    iFlatData = CMceComStreamBundle::NewL( aType );

    }