/*

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

#include "mcecomsession.h"

#include "mcesdpsession.h"

#include "mcesrvstream.h"

#include "mceevents.h"

#include "mcemmlogs.h"

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

// TMcePreparingStreams::TMcePreparingStreams

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

//

TMcePreparingStreams::TMcePreparingStreams ( 

                        CMceComSession& aSession,

                        TMceNegotiationRole aRole,

                        TMceSrvStreamIterator::TDirection aDirection )

    : TMceMediaState( aSession ),

      iIterator( TMceSrvStreamIterator( aSession.MccStreams(), aDirection ) )

    {

    SetRole( aRole );

    }

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

// TMcePreparingStreams::MccLinkCreatedL

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

//

void TMcePreparingStreams::MccLinkCreatedL( TMceMccComEvent& aEvent )

    {

    MCEMM_DEBUG("TMcePreparingStreams::MccLinkCreatedL(), Entry ");

    CMceSrvStream::EventReceived( iSession.MccStreams(), aEvent );

    CMceSrvStream* stream = NULL;

    iIterator.Reset();

    //try to find first stream, which is in state 'greater or equal' than link created

    //if no stream => all streams are in state link created

    //=> links are created

    if ( !iIterator.Next( stream, CMceSrvStream::ECreatingLink, 

                          TMceSrvStreamIterator::ExactMatch ) )

        {

        PrepareStreamsL();

        }

    else

        {

        MCEMM_DEBUG("TMcePreparingStreams::MccLinkCreatedL(): \

waiting links to be created");

        //just wait

        }

    MCEMM_DEBUG("TMcePreparingStreams::MccLinkCreatedL(), Exit ");

    }

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

// TMcePreparingStreams::MccMediaPreparedL

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

//

void TMcePreparingStreams::MccMediaPreparedL( TMceMccComEvent& aEvent )

    {

    MCEMM_DEBUG("TMcePreparingStreams::MccMediaPreparedL(), Entry ");

    CMceSrvStream::EventReceived( iSession.MccStreams(), aEvent );

    CMceSrvStream* stream = NULL;

    iIterator.Reset();

    //try to find first stream, which is in state 'greater or equal' than prepared

    //if no stream => all streams are in state prepared or stopped (or started, paused) 

    //=> streams are prepared        

    if ( !iIterator.Next( stream, CMceSrvStream::EPreparing, 

                          TMceSrvStreamIterator::ExactMatch ) )

        {

        StreamsPreparedL();

        }

    else

        {

        MCEMM_DEBUG("TMcePreparingStreams::MccMediaPreparedL(): \

waiting streams to be prepared");

        //just wait

        }

    MCEMM_DEBUG("TMcePreparingStreams::MccMediaPreparedL(), Exit ");

    }

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

// TMcePreparingStreams::MccMediaStartedL

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

//

void TMcePreparingStreams::MccMediaStartedL( TMceMccComEvent& aEvent )

    {

    MCEMM_DEBUG("TMcePreparingStreams::MccMediaStartedL(), Entry ");

    CMceSrvStream::EventReceived( iSession.MccStreams(), aEvent );

    CMceSrvStream* stream = NULL;

    iIterator.Reset();

    //try to find first stream, which is in state 'greater or equal' than stopped

    //if no stream => all streams are in state stopped, started or paused

    if ( !iIterator.Next( stream, CMceSrvStream::EStarting, 

                          TMceSrvStreamIterator::ExactMatch ) )

        {

        StreamsStartedL();

        }

    else

        {

        MCEMM_DEBUG("TMcePreparingStreams::MccMediaStartedL(): \

waiting streams to be started");

        //just wait

        }

    MCEMM_DEBUG("TMcePreparingStreams::MccMediaStartedL(), Exit ");

    }

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

// TMcePreparingStreams::MccMediaPausedL

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

//

void TMcePreparingStreams::MccMediaPausedL( TMceMccComEvent& aEvent )

    {

    MCEMM_DEBUG("TMcePreparingStreams::MccMediaPausedL(), Entry ");

    MccMediaStartedL( aEvent );

    MCEMM_DEBUG("TMcePreparingStreams::MccMediaPausedL(), Exit ");

    }

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

// TMcePreparingStreams::MccMediaResumedL

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

//

void TMcePreparingStreams::MccMediaResumedL( TMceMccComEvent& aEvent )

    {

    MCEMM_DEBUG("TMcePreparingStreams::MccMediaResumedL(), Entry ");

    MccMediaStartedL( aEvent );

    MCEMM_DEBUG("TMcePreparingStreams::MccMediaResumedL(), Exit ");

    }

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

// TMcePreparingStreams::PrepareStreamsL

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

//

void TMcePreparingStreams::PrepareStreamsL()

    {

    MCEMM_DEBUG("TMcePreparingStreams::PrepareStreamsL(), Entry ");

    CMceSrvStream* stream = NULL;

    TBool wait = EFalse;

    iIterator.Reset();

    while( iIterator.Next( stream, CMceSrvStream::ECreated ) )

        {

        MCEMM_DEBUG_STREAM( "TMcePreparingStreams::PrepareStreamsL(): \

create link", *stream );

        iSession.SdpSession().Manager().CreateMccLinkL( *stream );

        wait = !wait ? stream->State() != CMceSrvStream::ELinkCreated : wait;

        }

    if ( !wait )

        {

        iIterator.Reset();

        wait = EFalse;

        while( iIterator.Next( stream, CMceSrvStream::ELinkCreated ) )

            {

            MCEMM_DEBUG_STREAM( "TMcePreparingStreams::PrepareStreamsL(): \

create stream", *stream );

            iSession.SdpSession().Manager().CreateMccStreamL( *stream, iRole );

            }

        iIterator.Reset();

        wait = EFalse;

        while( iIterator.Next( stream, CMceSrvStream::ELinkCreated ) )

            {

            MCEMM_DEBUG_STREAM( "TMcePreparingStreams::PrepareStreamsL(): \

prepare stream", *stream );

            iSession.SdpSession().Manager().PrepareMccStreamL( *stream, iRole );

            wait = !wait ? stream->State() != CMceSrvStream::EPrepared : wait;

            }

        if (!wait)

            {

            MCEMM_DEBUG("TMcePreparingStreams::PrepareStreamsL(): streams prepared");

            StreamsPreparedL();

            }

        }

    MCEMM_DEBUG("TMcePreparingStreams::PrepareStreamsL(), Exit ");

    }

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

// TMcePreparingStreams::StartStreamsL

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

//

void TMcePreparingStreams::StartStreamsL( TBool aUpdateRemoteAddress )

    {

    MCEMM_DEBUG( "TMcePreparingStreams::StartStreamsL(), Entry" )

    // Hardware does not necessarily support two simulataneous mic users so

    // it is more safe to do pausing of old send stream before starting the

    // new one. This can be achieved by traversing streams in reverse order

    // as they are in priority order and new send stream has higher priority.

    //

    RPointerArray<CMceSrvStream>& origStreams = iSession.MccStreams();

    RPointerArray<CMceSrvStream> reverseOrderStream;

    CleanupClosePushL( reverseOrderStream );

    TInt lastIndex( origStreams.Count() - 1 );

    for ( TInt i = lastIndex; i >= 0; i-- )

        {

        reverseOrderStream.AppendL( origStreams[ i ] );

        }

    TMceSrvStreamIterator reversedIterator( reverseOrderStream, 

        iIterator.Direction() );

    TBool wait = EFalse;

    CMceSrvStream* stream = NULL;

    while( reversedIterator.Next( stream, CMceSrvStream::EPrepared, 

                            TMceSrvStreamIterator::GreaterOrEqualMatch ) )

        {

        const CMceSrvStream::TState state = stream->State();

        if ( state == CMceSrvStream::EPrepared &&

             stream->Codec().iIsEnabled )

            {

            MCEMM_DEBUG_STREAM( "TMcePreparingStreams::StartStreamsL() start stream",

                *stream )

            iSession.SdpSession().Manager().StartMccStreamL( *stream );

            wait = !wait ? stream->State() == CMceSrvStream::EStarting : wait;

            }

        else if ( aUpdateRemoteAddress )

            {

            MCEMM_DEBUG( "TMcePreparingStreams::StartStreamsL() remote address update" )

            iSession.SdpSession().Manager().SetRemoteAddressL( *stream );

            }

        else

            {

            // NOP

            }

        MCEMM_DEBUG_STREAM( "TMcePreparingStreams::StartStreamsL() synchronize stream",

            *stream )

        iSession.SdpSession().Manager().SynchronizeMccStreamL( *stream, iRole );    

        }

    if ( !wait )

        {

        MCEMM_DEBUG( "TMcePreparingStreams::StartStreamsL(): streams started" )

        StreamsStartedL();

        }

    CleanupStack::PopAndDestroy( &reverseOrderStream );

    MCEMM_DEBUG( "TMcePreparingStreams::StartStreamsL(), Exit" )

    }