/*
* 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:    
*
*/




#ifndef CMCECOMENDPOINT_H
#define CMCECOMENDPOINT_H

#include "mcecomserializable.h"

#ifdef MCE_COMMON_SERVER_SIDE
class TMceMccComEvent;
#endif//MCE_COMMON_SERVER_SIDE

class TMceComFactory;
class TMceComEvent;
class CMceComMediaStream;
class CMceComCodec;
class MMceComEndPointProxy;
class CMceItcSender;
class RMce;

const TBool KMceEnabledLocal = ETrue;
const TBool KMceEnabledE2e = EFalse;

typedef TUint8 TMceEndpointCategory;

/**
 * 
 *
 * @lib 
 */
class CMceComEndpoint: public CBase, 
                       public MMceComSerializable
	{

public: // Destructor

	~CMceComEndpoint();


public: // from MMceComSerializableMedia


    /**
    * Returns serialization id
    * @return serialization id
    */
    TUint64 SerializationId() const;
    
    /**
    * Internalizes flat data
    * @param aReadStream read stream
    */
    void InternalizeFlatL( RReadStream& aReadStream );

    /**
    * Externalizes flat data
    * @param aWriteStream write stream
    */
    void ExternalizeFlatL( RWriteStream& aWriteStream );
    
    /**
    * Internalizes
    * @param aSerCtx context for serialization
    */
    void InternalizeL( MMceComSerializationContext& aSerCtx );
    
    /**
    * Externalizes
    * @param aSerCtx context for serialization
    */
    void ExternalizeL( MMceComSerializationContext& aSerCtx );
    

public: // new functions

    /**
    * Return category of endpoint.
    * @return category of endpoint
    */
    TMceEndpointCategory Category() const;
    
    /**
    * Returns type of endpoint. NOTE, sources and sinks have currently
    * overlapping type values so type value checking is not safe without
    * knowing endpoint category. TBD: remove overlapping from API
    * @return type of endpoint
    */
    TUint8 Type() const;

    /**
    * ID 
    * @return ID
    */
	TMceMediaId Id() const;

    /**
    * Factory
    * @return factory
    */
    TMceComFactory BaseFactory();

    /**
    * Sets and gets reference count describing to how many
    * streams sink is associated
    * @return reference count reference
    */
    TInt& ReferenceCount();

	/**
    * Parent object
    * @return Parent object
    */
	CMceComMediaStream* MediaStream() const;

    /**
    * equal operator
    * @param aEndpoint the enpoint
    * @return ETrue, if equal
    */
    TBool operator==( const CMceComEndpoint& aEndpoint ) const;

    /**
    * Stream is been deleted
    * @param aParent the parent stream
    */
    void UnInitialize( CMceComMediaStream& aParent );


public: // virtual functions


    /**
    * Returns ETrue, if enabled
    * @param aLocally, if KMceEnabledLocal means locally enabled,
    *                  KMceEnabledE2e means that local and remote 
    *                  endpoints are enabled.
    * @return ETrue, if enabled
    */
    virtual TBool IsEnabled( TBool aLocally = KMceEnabledLocal ) const;

    /**
    * Sets enabled flag
    * @param aValue enabled/disabled
    */
    void Enabled( TBool aValue );
	
    /**
    * Traversal event handler
    * @param aEvent the event
    * @return status, if event was consumed or not or object needs update
    */
    virtual TInt EventReceivedL( TMceComEvent& aEvent ) = 0;
    
    /**
    * Initializes 
    * @param aParent the parent
    */
    virtual void InitializeL( CMceComMediaStream& aParent );
    
    /**
    * Stream has been added to session
    * @param aParent the parent stream
    */
    virtual void StreamAddedL( CMceComMediaStream& aParent );

    /**
    * Returns endpoint proxy
    * @return endpoint proxy
    */
	MMceComEndPointProxy* EndpointProxy() const;

    /**
    * Called when stream bundle has beed added to prepare proxy for it
    * @param aEndpointProxy endpoint proxy setup by another endpoint or NULL
    */
    void SetupEndpointProxyL( MMceComEndPointProxy* aEndpointProxy );

    /**
    * Called endpoint proxy must be created
    * @return endpointProxy
    */
    virtual MMceComEndPointProxy* CreateEndpointProxyL() const;

    /**
    * Should this endpoint use endpoint proxy
    * @return ETrue, this endpoint uses endpoint proxy
    */
    virtual TBool UsesEndpointProxy() const;

    /**
    * Is this endpoint re-usable
    * @return ETrue, if this endpoint is re-usable
    */
    virtual TBool Reusable( const CMceComMediaStream& aParent ) const;     
    /**
    * Should use RTCP
    * return ETrue, if uses RTCP
    */
    virtual TBool UseRTCP();
    

#ifdef MCE_COMMON_SERVER_SIDE


public: //virtual functions 

    /**
    * Returns mcc type for mcc endpoint
    * @return mcc type
    */
    virtual const TUid MccType() = 0;
    
    /**
    * Returns init param for mcc endpoint
    * @return mcc type
    */
    virtual const TDesC8& InitParamL( const CMceComCodec& aCodec);
    
    /**
    * Endpoint can be informed about initialization completion
    */
    virtual void InitializedL();
    
    /**
    * Enables 'locally' this endpoint
    * @param aCodec the codec associated to this endpoint
    */
    virtual void EnableL( const CMceComCodec& aCodec );
    
    /**
    * Disables 'locally' this endpoint
    */
    virtual void DisableL();
    
    /**
    * Prepares this endpoint
    */
    virtual void PrepareL();
    
    /**
    * Called after endpoint has been prepared.
    * @return error code
    */ 
    virtual TInt DoPrepared();


public: //new functions 

    /**
    * Handles event received from mcc
    * @param aEvent the event from mcc
    */
    void EventReceived( TMceMccComEvent& aEvent );
    
    /**
    * Sets state
    * @param aEvent the event from mcc
    */
    void SetState( TMceMccComEvent& aEvent );

    void Merge( CMceComEndpoint& aMergeWith );
    
#else // MCE CLIENT SIDE

    /**
    * Gets itc sender.
    * @param aItcProvider
    */
    CMceItcSender& SenderL( RMce& aItcProvider );
#endif//MCE_COMMON_SERVER_SIDE


protected: 

    /**
    * Updates 
    * @param aEndpoint an endpoint
    */
    void BaseUpdateL( CMceComEndpoint& aEndpoint );
    
    /**
    * Zeroes instance (used in cloning)
    */
    void Zero();
    
    
protected:

    /**
     * C++ default constructor.
     * @param aType
     */
	CMceComEndpoint( TMceEndpointCategory aCategory, TUint8 aType );
		

public://serialized data

    /**
     * category of endpoint
     */
    TMceEndpointCategory iCategory;
    
    /**
     * type of endpoint
     */
    TUint8 iType;

    /**
     * ID
     */
    TMceMediaId iID;

    /**
     * reference count
     */
    TInt iReferenceCount;



protected://owned

    /**
     * proxy
     */
    MMceComEndPointProxy* iEndpointProxy;

    /**
     * Is enabled
     */
    TBool iIsEnabled;
    
    /**
    * Itc sender used by client when endpoint is not attached to session.
    */
    CMceItcSender* iItcSender;

private://NOT owned


	/**
    * Parent stream (one of)
    */
	CMceComMediaStream* iStream;
	
	/**
    * Parent streams
    */
	RPointerArray<CMceComMediaStream> iParents;
    
	//definitions for unit testing
	friend class UT_CMceSrvSource;
	};


#endif // CMCECOMENDPOINT_H