/*

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

#include "mcesession.h"

#include "mcemanager.h"

#include "mcemediasink.h"

#include "mcecommediasink.h"

#include "mceitcsender.h"

#include "mcefactory.h"

#include "mceevents.h"

#include "mceendpointproxy.h"

#include "mceclilogs.h"

#define _FLAT_DATA static_cast<CMceComMediaSink*>( iFlatData )

#define FLAT_DATA( data ) _FLAT_DATA->data

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

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

// CMceMediaSink::~CMceMediaSink

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

//

EXPORT_C CMceMediaSink::~CMceMediaSink()

    {

    delete iFlatData;

    iParents.Reset();

    iParents.Close();

    }

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

// CMceMediaSink::Type

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

//

EXPORT_C TMceSinkType CMceMediaSink::Type() const

    {

    return FLAT_DATA( Type() );

    }

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

// CMceMediaSink::IsEnabled

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

//

EXPORT_C TBool CMceMediaSink::IsEnabled() const

    {

    return FLAT_DATA( IsEnabled() );

    }

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

// CMceMediaSink::Id

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

//

TMceMediaId CMceMediaSink::Id() const

    {

    return FLAT_DATA( iID ); 

    }

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

// CMceMediaSink::ConstructL

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

//

void CMceMediaSink::ConstructL( CMceComMediaSink* aFlatData ) 

    {

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

    iFlatData = aFlatData;

    FLAT_DATA( iID ) = TMceMediaId();//as not assigned

    }

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

// CMceMediaSink::CMceMediaSink

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

//

CMceMediaSink::CMceMediaSink()

    {

    }

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

// CMceMediaSink::CreateEndpointProxyL

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

//

MMceEndPointProxy* CMceMediaSink::EndpointProxy() const

    {

    return iEndpointProxy;

    }

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

// CMceMediaSink::CreateEndpointProxyL

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

//

MMceEndPointProxy* CMceMediaSink::CreateEndpointProxyL() const

    {

    return NULL;

    }

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

// CMceMediaSink::UsesEndpointProxy

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

//

TBool CMceMediaSink::UsesEndpointProxy() const

    {

    return EFalse;

    }

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

// CMceMediaSink::SetupEndpointProxyL

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

//

void CMceMediaSink::SetupEndpointProxyL( MMceEndPointProxy* aEndpointProxy )

    {

    if ( !UsesEndpointProxy() )

        {

        return;

        }

    if ( !aEndpointProxy && !iEndpointProxy )

        {

        iEndpointProxy = CreateEndpointProxyL();

        iEndpointProxy->AddProxyClientL( *this );

        }

    else if ( aEndpointProxy && !iEndpointProxy )

        {

        aEndpointProxy->AddProxyClientL( *this );

        iEndpointProxy = aEndpointProxy;

        }

    else

        {

        iEndpointProxy->AddProxyClientL( *this );

        }

    }

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

// CMceMediaSink::SerializationId

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

//

TUint64 CMceMediaSink::SerializationId() const

    {

    return FLAT_DATA( SerializationId() );

    }

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

// CMceMediaSink::InternalizeFlatL

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

//

void CMceMediaSink::InternalizeFlatL( RReadStream& aReadStream )

    {

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

    _FLAT_DATA->InternalizeFlatL( aReadStream );

    }

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

// CMceMediaSink::ExternalizeFlatL

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

//

void CMceMediaSink::ExternalizeFlatL( RWriteStream& aWriteStream )

    {

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

    _FLAT_DATA->ExternalizeFlatL( aWriteStream );

    }

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

// CMceMediaSink::InternalizeL

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

//

void CMceMediaSink::InternalizeL( MMceComSerializationContext& aSerCtx )

    {

    InternalizeFlatL( aSerCtx.ReadStream() );

    }

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

// CMceMediaSink::ExternalizeL

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

//

void CMceMediaSink::ExternalizeL( MMceComSerializationContext& aSerCtx )

    {

    ExternalizeFlatL( aSerCtx.WriteStream() );

    }

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

// CMceMediaSink::Factory

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

//

TMceSinkFactory CMceMediaSink::Factory()

    {

    return TMceSinkFactory();

    }

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

// CMceMediaSink::DoITCSendL

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

//

void CMceMediaSink::DoITCSendL(TUint8 aITCFunction, TBool aEnabled)

    {    

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

    CMceSession* session = iStream->Session();

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

	TMceIds ids;

	session->PrepareForITC( ids );

	ids.iMediaID   = iStream->Id();

	ids.iSinkID    = Id();

	ids.iState     = aEnabled;

    session->ITCSender().SendL( ids, static_cast<TMceItcFunctions>( aITCFunction ) );

	Enabled( static_cast<TBool>( ids.iState ) );

    }

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

// CMceMediaSink::DoEnableL

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

//

void CMceMediaSink::DoEnableL() 

    {

    if ( MCE_ENDPOINT_ITC_ALLOWED( *this ) )

        {

    	DoITCSendL( EMceItcEnable, ETrue );    

        }

    else

        {

        MCECLI_DEBUG("CMceMediaSink::DoEnableL, done locally");

    	Enabled( ETrue );

        }    

    }

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

// CMceMediaSink::DoDisableL

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

//

void CMceMediaSink::DoDisableL() 

    {

    if ( MCE_ENDPOINT_ITC_ALLOWED( *this ) )

        {

        __ASSERT_ALWAYS( iStream->State() != CMceMediaStream::ETranscodingRequired, 

                         User::Leave( KErrNotReady ) );

    	DoITCSendL( EMceItcDisable, EFalse );    

        }

    else

        {

    	Enabled( EFalse );

        MCECLI_DEBUG("CMceMediaSink::DoDisableL, done locally");

        }    

    }

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

// CMceMediaSink::Enabled

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

//

void CMceMediaSink::Enabled( TBool aValue )

    {

	_FLAT_DATA->Enabled( aValue );

    }

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

// CMceMediaSink::InitializeL

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

//

void CMceMediaSink::InitializeL( CMceManager* /*aManager*/ )

    {

    // NOP

    }

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

// CMceMediaSink::InitializeL

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

//

void CMceMediaSink::InitializeL( CMceMediaStream& aParent )

    {

    if ( !Id().IsAssigned() )

        {

	    __ASSERT_ALWAYS( aParent.Session(), User::Leave( KErrNotFound ) );

        FLAT_DATA( iID ) = aParent.Session()->Manager().NextMediaId();

        MCECLI_DEBUG_DVALUES2("CMceMediaSink::InitializeL, this: type", Type(),

                              "id", Id().iId, "enabled", IsEnabled() );

        }    

    }

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

// CMceMediaSink::StreamAddedL

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

//

void CMceMediaSink::StreamAddedL( CMceMediaStream& aParent )

    {

    if ( iParents.Find( &aParent ) == KErrNotFound )

        {

        iParents.AppendL( &aParent );

        }

    iStream = iParents[0];

    }

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

// CMceMediaSink::UnInitialize

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

//

void CMceMediaSink::UnInitialize( CMceMediaStream& aParent )

    {

    TInt index = iParents.Find( &aParent );

    if ( index >= 0 )

        {

        iParents.Remove( index );

        }

    iStream = NULL;

    if ( iParents.Count() > 0 )

        {

        iStream = iParents[0];

        }

    }

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

// CMceMediaSink::EventReceivedL

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

//

TInt CMceMediaSink::EventReceivedL( TMceEvent& aEvent )

    {

    TInt status = KMceEventNotOwner;

    TBool idMatch = aEvent.Id().iSinkID == Id();

    if ( !idMatch )

        {

        return KMceEventNotOwner;

        }

    if ( aEvent.Id().IsSinkId() )

        {

        status = HandleEvent( aEvent );

        }

    else

        {

        status = KMceEventNotConsumed;

        }

    return status;

    }

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

// CMceMediaSink::UpdateL

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

//

void CMceMediaSink::UpdateL( CMceMediaSink& aUpdate )

    {

    MCECLI_DEBUG("CMceMediaSink::UpdateL, Entry");

    MCECLI_DEBUG_DVALUES("this: type", Type(), "id", Id().iId );

    iFlatData->UpdateL( *aUpdate.iFlatData );

    MCECLI_DEBUG_DVALUE("CMceMediaSink::UpdateL, before exit. enabled", IsEnabled() );

    MCECLI_DEBUG("CMceMediaSink::UpdateL, Exit");

    }

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

// CMceMediaSink::ReferenceCount

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

//

TInt& CMceMediaSink::ReferenceCount()

    {

    return FLAT_DATA( ReferenceCount() );

    }

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

// CMceMediaSink::Updated

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

//

void CMceMediaSink::Updated()

    {

    MMceStreamObserver* observer = iStream->Session()->Manager().MediaObserver();

    if ( observer )

        {

        observer->StreamStateChanged( *iStream, *this );

        }

    }

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

// CMceMediaSink::HandleEvent

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

//

TInt CMceMediaSink::HandleEvent( TMceEvent& aEvent )

    {

    MCECLI_DEBUG("CMceMediaSink::HandleEvent, Entry");

    MCECLI_DEBUG_DVALUES("this: type", Type(), "id", Id().iId );

    TInt status = KMceEventNotConsumed;

    if ( aEvent.MessageType() == EMceItcMsgTypeSink )

        {

        MCECLI_DEBUG("CMceMediaSink::HandleEvent, content of sink changed");

        status = KMceEventUpdate;

        }

    else if ( aEvent.Action() == EMceItcStateChanged ) 

        {

        MCECLI_DEBUG("CMceMediaSink::HandleEvent, state changed");

    	Enabled( static_cast<TBool>( aEvent.ActionData() ) );

        if ( IsEnabled() )

            {

            iStream->SetState( CMceMediaStream::EStreaming );

            }

        else

            {

            iStream->SetState( CMceMediaStream::EDisabled );

            }

        Updated();

        status = KMceEventConsumed;

        }

    else if ( aEvent.Action() == EMceItcInProgress ) 

        {

        MCECLI_DEBUG("CMceMediaSink::HandleEvent, stream state changed");

        TInt stateContent( 0 );

        TBool isEnabled( EFalse );

        TUint32 actionData = aEvent.ActionData();

        MCE_DECODE_DOUBLE_STATE( actionData, stateContent, isEnabled );     

        CMceMediaStream::TState state = static_cast<CMceMediaStream::TState>( stateContent );

        MCECLI_DEBUG_DVALUE("CMceMediaSink::HandleEvent, state:", state );

        MCECLI_DEBUG_DVALUE("CMceMediaSink::HandleEvent, enabled:", isEnabled );

        Enabled( isEnabled );

        TBool stateChanged = iStream->SetState( state );

        if ( !iStream->HandleMediaError( state, isEnabled, aEvent.Id().iStatus ) && 

             stateChanged )

            {

            Updated();

            }

        status = KMceEventConsumed;

        }

    else

        {

        //NOP

        MCECLI_DEBUG("CMceMediaSink::HandleEvent, not consumed");

        }

    MCECLI_DEBUG_DVALUE("CMceMediaSink::HandleEvent, before exit. enabled", IsEnabled() );

    MCECLI_DEBUG_DVALUE("CMceMediaSink::HandleEvent, Exit. status", status );

    return status;

    }