/*
* Copyright (c) 2006 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 "mceavsink.h"
#include "mcemanager.h"
#include "mcecomavsink.h"
#include "mce.h"
#include "mcemediastream.h"
#include "mcefactory.h"
#include "mceevents.h"
#include "mceclilogs.h"

#include <w32std.h>


#define _FLAT_DATA static_cast<CMceComAvSink*>( iFlatData )
#define FLAT_DATA( data ) _FLAT_DATA->data

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


// -----------------------------------------------------------------------------
// 
// -----------------------------------------------------------------------------
//
CMceAvSink* CMceAvSink::NewL()
    {
    CMceAvSink* self = CMceAvSink::NewLC();
    CleanupStack::Pop( self );
    return self;
    }


// -----------------------------------------------------------------------------
// 
// -----------------------------------------------------------------------------
//
CMceAvSink* CMceAvSink::NewLC()
    {
    CMceAvSink* self = new (ELeave) CMceAvSink();
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
    }


// -----------------------------------------------------------------------------
// 
// -----------------------------------------------------------------------------
//
CMceAvSink::~CMceAvSink()
    {
    delete iFlatData;
    iParents.Close();
    iProxyClients.Close();
    }

// -----------------------------------------------------------------------------
// CMceAvSink::Type
// -----------------------------------------------------------------------------
//
TMceSinkType CMceAvSink::Type() const
    {
    return FLAT_DATA( Type() );
    }
    


// -----------------------------------------------------------------------------
// CMceAvSink::IsEnabled
// -----------------------------------------------------------------------------
//
TBool CMceAvSink::IsEnabled() const
    {
    return FLAT_DATA( IsEnabled() );
    }

    
// -----------------------------------------------------------------------------
// CMceAvSink::Id
// -----------------------------------------------------------------------------
//
TMceMediaId CMceAvSink::Id() const
    {
    return FLAT_DATA( iID ); 
    }

    
// -----------------------------------------------------------------------------
// CMceAvSink::ConstructL
// -----------------------------------------------------------------------------
//
void CMceAvSink::ConstructL() 
    {
    iFlatData = CMceComAvSink::NewL();
    FLAT_DATA( iID ) = TMceMediaId();//as not assigned
    
    }
    

// -----------------------------------------------------------------------------
// CMceAvSink::CMceAvSink
// -----------------------------------------------------------------------------
//
CMceAvSink::CMceAvSink()
    {
    }

// -----------------------------------------------------------------------------
// CMceAvSink::SerializationId
// -----------------------------------------------------------------------------
//
TUint64 CMceAvSink::SerializationId() const
    {
    return FLAT_DATA( SerializationId() );
    }

// -----------------------------------------------------------------------------
// CMceAvSink::InternalizeFlatL
// -----------------------------------------------------------------------------
//
void CMceAvSink::InternalizeFlatL( RReadStream& aReadStream )
    {
    __ASSERT_ALWAYS( iFlatData , User::Leave( KErrNotReady ) );
    _FLAT_DATA->InternalizeFlatL( aReadStream );
    }

// -----------------------------------------------------------------------------
// CMceAvSink::ExternalizeFlatL
// -----------------------------------------------------------------------------
//
void CMceAvSink::ExternalizeFlatL( RWriteStream& aWriteStream )
    {
    __ASSERT_ALWAYS( iFlatData , User::Leave( KErrNotReady ) );
    _FLAT_DATA->ExternalizeFlatL( aWriteStream );
    }

// -----------------------------------------------------------------------------
// CMceAvSink::InternalizeL
// -----------------------------------------------------------------------------
//
void CMceAvSink::InternalizeL( MMceComSerializationContext& aSerCtx )
    {
    InternalizeFlatL( aSerCtx.ReadStream() );
    }

// -----------------------------------------------------------------------------
// CMceAvSink::ExternalizeL
// -----------------------------------------------------------------------------
//
void CMceAvSink::ExternalizeL( MMceComSerializationContext& aSerCtx )
    {
    ExternalizeFlatL( aSerCtx.WriteStream() );
    }
    

// -----------------------------------------------------------------------------
// CMceAvSink::Factory
// -----------------------------------------------------------------------------
//
TMceSinkFactory CMceAvSink::Factory()
    {
    return TMceSinkFactory();
    }


// -----------------------------------------------------------------------------
// CMceAvSink::ServesProxyClient
// -----------------------------------------------------------------------------
//
TBool CMceAvSink::ServesProxyClient( const CMceMediaSink& aClient ) const
    {
    TBool found = EFalse;
    TInt index = 0;
    while ( !found && index < iProxyClients.Count() )
        {
        found = iProxyClients[ index ++ ]->Id() == aClient.Id();
        }
    
    return found;
    
    }


// -----------------------------------------------------------------------------
// CMceAvSink::AddProxyClientL
// -----------------------------------------------------------------------------
//
void CMceAvSink::AddProxyClientL( CMceMediaSink& aClient )
    {
    iProxyClients.AppendL( &aClient );
    ReferenceCount()++;
    }

// -----------------------------------------------------------------------------
// CMceAvSink::RemoveProxyClient
// -----------------------------------------------------------------------------
//
void CMceAvSink::RemoveProxyClient( CMceMediaSink& aClient )
    {
    TInt index = iProxyClients.Find( &aClient );
    if ( index >= 0 )
        {
        iProxyClients.Remove( index );
        ReferenceCount()--;
        }
    }

// -----------------------------------------------------------------------------
// CMceAvSink::EnableL
// -----------------------------------------------------------------------------
//
void CMceAvSink::EnableL()
    {
	_FLAT_DATA->Enabled( ETrue );
    }


// -----------------------------------------------------------------------------
// CMceAvSink::DisableL
// -----------------------------------------------------------------------------
//
void CMceAvSink::DisableL()
    {
	_FLAT_DATA->Enabled( EFalse );
    }



// -----------------------------------------------------------------------------
// CMceAvSink::InitializeL
// -----------------------------------------------------------------------------
//
void CMceAvSink::InitializeL( CMceManager* /*aManager*/ )
    {
    // NOP
    }
    

// -----------------------------------------------------------------------------
// CMceAvSink::InitializeL
// -----------------------------------------------------------------------------
//
void CMceAvSink::InitializeL( CMceMediaStream& aParent )
    {
    StreamAddedL( aParent );
    iStream = iParents[0];
    
    if ( !Id().IsAssigned() )
        {
	    __ASSERT_ALWAYS( iStream->Session(), User::Leave( KErrNotFound ) );
        FLAT_DATA( iID ) = iStream->Session()->Manager().NextMediaId();
        MCECLI_DEBUG("CMceAvSink::InitializeL, initialized:" );
        MCECLI_DEBUG_DVALUE("id", Id().iId );
        
        }    
    }


// -----------------------------------------------------------------------------
// CMceAvSink::StreamAddedL
// -----------------------------------------------------------------------------
//
void CMceAvSink::StreamAddedL( CMceMediaStream& aParent )
    {
    
    if ( iParents.Find( &aParent ) == KErrNotFound )
        {
        iParents.AppendL( &aParent );
        }
    
    }

// -----------------------------------------------------------------------------
// CMceAvSink::UnInitialize
// -----------------------------------------------------------------------------
//
void CMceAvSink::UnInitialize( CMceMediaStream& aParent )
    {
    TInt index = iParents.Find( &aParent );
    if ( index >= 0 )
        {
        iParents.Remove( index );
        }
    iStream = NULL;
    
    if ( iParents.Count() > 0 )
        {
        iStream = iParents[0];
        }
    
    }
    
// -----------------------------------------------------------------------------
// CMceAvSink::EventReceivedL
// -----------------------------------------------------------------------------
//
TInt CMceAvSink::EventReceivedL( TMceEvent& /*aEvent*/ )
    {
    TInt status = KMceEventNotOwner;
    return status;
    
    }

// -----------------------------------------------------------------------------
// CMceAvSink::UpdateL
// -----------------------------------------------------------------------------
//
void CMceAvSink::UpdateL( CMceAvSink& aUpdate )
    {
    _FLAT_DATA->UpdateL( *aUpdate.iFlatData );
    }

// -----------------------------------------------------------------------------
// CMceAvSink::ReferenceCount
// -----------------------------------------------------------------------------
//
TInt& CMceAvSink::ReferenceCount()
    {
    return FLAT_DATA( ReferenceCount() );
    }

// -----------------------------------------------------------------------------
// CMceAvSink::Updated
// -----------------------------------------------------------------------------
//
void CMceAvSink::Updated()
    {
    //NOP
    }


// -----------------------------------------------------------------------------
// CMceAvSink::HandleEvent
// -----------------------------------------------------------------------------
//
TInt CMceAvSink::HandleEvent( TMceEvent& /*aEvent*/ )
    {
    TInt status = KMceEventNotConsumed;
    return status;
    
    }