/*

* 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 CMCECOMMEDIASTREAM_H

#define CMCECOMMEDIASTREAM_H

#include <e32std.h>  	

#include <e32base.h>

#include <s32strm.h>

#include <in_sock.h>

#include "mcemediastream.h"

#include "mcedefs.h"

#include "mceclientserver.h"

#include "mcecomserializable.h"

#ifdef MCE_COMMON_SERVER_SIDE

#include <mmccinterfacedef.h>

#include <mmccsecureinterface.h>

class TMceMccComEvent;

class CMceMediaManager;

#endif//MCE_COMMON_SERVER_SIDE

class TMceComFactory;

class TMceComMediaStreamFactory;

class TMceComEvent;

class CMceComSession;

class TMceMccComEvent;

class CMceComCodec;

class CMceComMediaSource;

class CMceComMediaSink;

class MMceComSerializationContext;

class TMcePreconditions;

class CSdpMediaField;

#define IS_SENDSTREAM( stream )\

    ( ( stream )->iStreamType == CMceComMediaStream::ESendStream ||\

      ( stream )->iStreamType == CMceComMediaStream::ESendOnlyStream )

#define IS_RECEIVESTREAM( stream )\

    ( ( stream )->iStreamType == CMceComMediaStream::EReceiveStream ||\

      ( stream )->iStreamType == CMceComMediaStream::EReceiveOnlyStream )

const TBool KMceNoEndpointAdjustment = EFalse;

const TBool KMceEndpointAdjustment = ETrue;

const TBool KMceRoleAnswerer = ETrue;

const TBool KMceRoleOfferer = EFalse;

/**

 * 

 *

 * @lib 

 */

class CMceComMediaStream: public CBase,

                          public MMceComSerializable

	{

public: // Destructor

    enum TStreamType

        {

        ELocalStream,

        ESendOnlyStream,

        EReceiveOnlyStream,

        ESendStream,

        EReceiveStream

        };

public: // Destructor

    /**

    * Destructor.

    */

	~CMceComMediaStream();

public: // Source and sink functions

    /**

    * Adds source to the stream.

    * @param aSource source to be added to the stream.

    */

	void SetSourceL( CMceComMediaSource* aSource );

    /**

    * Adds sink to the stream.

    * @param aSink sink to be added to the stream.

    */

	void AddSinkL( CMceComMediaSink* aSink );

    /**

    * Deletes sink

    * @param aIndex index of sink in the array

    */

    void DeleteSink( TInt aIndex );

    /**

    * Removes codec from stream

    * @param aCodec the codec

    */

    virtual void RemoveCodecL( CMceComCodec* aCodec ) = 0;

	/**

	* Clears list of codecs and deletes each codec in it.

	*/

    virtual void DestroyCodecs() = 0;

    /**

    * Searches for codec matching with input codec instance or sdp name

    * @param aCodec the search term

    * @return matching codec or NULL if not found

    */

    virtual CMceComCodec* FindCodecL( CMceComCodec& aCodec ) = 0;

    /**

    * Adds codec to the stream.

    * @param aCodec codec to be added to the stream.

	*	     Ownership is transferred.

    */

	virtual void AddCodecL( CMceComCodec* aCodec ) = 0;

    /**

    * Gets source of the stream. Returns null is source not set.

    * @return source of the stream. Ownership is not transferred.

    */

	CMceComMediaSource* Source();

    /**

    * Gets array of sinks of the stream.

    * @return array of sinks.

    */

	RPointerArray<CMceComMediaSink>& Sinks();

	virtual void ReorderCodecs() = 0;

public: // Binding opposite way stream

    /**

    * Binds opposite direction stream to this stream.

    * @param aStream another stream to be bind to the stream.

    */

	 void BindL( CMceComMediaStream* aStream );

    /**

    * Gets opposite direction stream of this stream.

    * @return opposite direction stream.

    */

	 CMceComMediaStream& BoundStreamL();

    /**

    * Checks if opposite direction stream is set.

    * @return ETrue if opposite direction stream is set.

    */

	 TBool BoundStream() const;

    /**

    * Checks if this is binder (biding owner)

    * @return ETrue if this is binder (biding owner)

    */

	TBool Binder() const;

    /**

    * Gives 'main' stream

    * @return 'main' stream

    */

	CMceComMediaStream& operator()();

    /**

    * Gives 'main' stream

    * @return 'main' stream

    */

	const CMceComMediaStream& operator()() const;

    /**

    * Gives send stream

    * @return send stream

    */

    CMceComMediaStream* SendStream();

    /**

    * Gives receive stream

    * @return receive stream

    */

    CMceComMediaStream* ReceiveStream();

    /**

    * Gives offer stream

    * @return offer stream

    */

    CMceComMediaStream* OfferStream();

    /**

    * Gives answer stream

    * @return answer stream

    */

    CMceComMediaStream* AnswerStream();

    /**

    * Gives sdp index

    * @return sdp index

    */

    TInt& SdpIndex();

public: //from MMceComSerializable

    /**

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

    /**

    * Factory

    * @return factory

    */

    TMceComFactory BaseFactory();

    /**

    * Factory

    * @return factory

    */

    static TMceComMediaStreamFactory Factory();

    /**

    * Adds source, during serialization, to the stream.

    * @param aSerCtx serialization context

    */

	void SetSourceL( MMceComSerializationContext& aSerCtx );

    /**

    * Adds sink, during serialization, to the stream.

    * @param aSerCtx serialization context

    */

	void AddSinkL( MMceComSerializationContext& aSerCtx );

public:// new Functions

    /**

    * ID 

    * @return ID

    */

	TMceMediaId Id() const;

    /**

    * Parent object

    * @return Parent object

    */

	CMceComSession* Session() const;

    /**

    * Initializes 

    * @param aParent the parent

    */

    virtual void InitializeL( CMceComSession& aParent );

    /**

    * Traversal event handler

    * @param aEvent the event

    * @return status, if event was consumed or not or object needs update

    */

    virtual TInt EventReceivedL( TMceComEvent& aEvent );

    /**

    * Updates 

    * @param aStream new stream

    */

    virtual void UpdateL( CMceComMediaStream& aStream );

    /**

    * Clones whole stream object

    * @return cloned stream object

    */

    virtual CMceComMediaStream* CloneL() = 0;

public:// new Functions

    /**

    * Returns ETrue, if enabled

    * @return ETrue, if enabled

    */

    virtual TBool IsEnabled();

    /**

    * Sets remote media port

    * @param aPort remote media port

    */

	void SetRemoteMediaPort( TUint aPort );

	/**

    * Sets remote rtcp media address

    * @param aAddr remote rtcp media address

    */

	void SetRemoteRtcpMediaAddrL( TDesC16& aAddr );

    /**

    * Sets local media port

    * @param aPort local media port

    */

    void SetLocalMediaPort( TUint aPort );

    /**

    * Gets remote media port

    * @return remote media port

    */

	TUint RemoteMediaPort() const;

    /**

    * Gets local media port

    * @return local media port

    */

	TUint LocalMediaPort() const;

    /**

    * Sets remote media port

    * @param aPort remote media port

    */

	void SetRemoteRtcpMediaPort( TUint aPort );

	/**

	* Checks whether remote media port has changed

	* @return ETrue if port has changed, otherwise return EFalse

	*/

	TBool RemoteMediaPortChanged( TUint aNewPort );

	/**

	* Checks whether remote RTCP address, and port has changed 

	* @return ETrue if port has changed, otherwise return EFalse

	*/

	/**

    * Stores remote port.

    * @param aIgnore, ETrue if remote port comparison should be ignored

    */

	void SetIgnoreRemotePort( TBool aIgnore );

    TBool& DowngradedEndpoints();

#ifdef MCE_COMMON_SERVER_SIDE

public:// new (virtual) Functions

    /**

    * Called when stream has been decoded

    * @param aDecodedOffer is offer decoded

    */

    void DecodedL( TBool aRoleAnswerer );

    /**

    * Synchronizes stream's codecs.

    * @param aRoleAnswerer is answerer

    */

    virtual void SynchronizeL( TBool aRoleAnswerer ) = 0;

    /**

    * Update default codec to reflect current negotiation

    */

    virtual void UpdateDefaultCodecL() = 0;

    /**

    * Prepares

    */

    virtual void PrepareL() = 0;

    /**

    * Return mcc stream type

    * @return mcc stream type

    */

    virtual TInt MccStreamType() const = 0;

    /**

    * Return mcc link type

    * @return mcc link type

    */

    virtual TInt MccLinkType() const = 0;

    /**

    * Handles event received from mcc

    * @param aEvent the event from mcc

    */

    virtual void EventReceived( TMceMccComEvent& aEvent );

public:// new Functions

    /**

    * Sets state 

    * @param aEvent the event from mcc

    */

    void SetState( TMceMccComEvent& aEvent );

    /**

    * Sets link id

    * @param aLinkId the link id

    */

    void SetLinkId( TUint32 aLinkId );

    /**

    * Gets direction

    * @return direction

    */

    TInt Direction();

    /**

    * Sets direction

    * @param aDirection direction

    * @param aEndpointAdjustment should endpoints follow

    */

    void SetDirection( TInt aDirection, TBool aEndpointAdjustment = KMceEndpointAdjustment );

    /**

    * Sets direction. Leaves if not allowed

    * @param aDirection direction

    */

    void SetDirectionL( TInt aDirection );

    /**

    * Sets stream enabled/disabled

    * @param aEnable if ETrue stream and sinks/source 

    * is set enabled

    * @param aEndpointAdjustment if endpoints follow

    */

    void Enable( TBool aEnable, TBool aEndpointAdjustment );

    /**

    * Gets SDP stream type

    * @return SDP stream type

    */

    TInt SdpStreamType();

    /**

    * Gets or creates preconditions

    * @param aModifier mce preconditon modifier

    * @param aMediaLine media line

    * @return preconditions

    */

    TMcePreconditions* PreconditionsL( TMceSessionModifier aModifier,

    									CSdpMediaField* aMediaLine = NULL );

    /**

    * Gets preconditions

    * @return preconditions

    */

    const RPointerArray<TMcePreconditions>& Preconditions() const ;

    /**

    * CopyPrecondition parameters 

    * @param aModifier mce preconditon modifier

    * @return void

    */

    void CopyPreconditionL( TMceSessionModifier aModifier );

    /**

    * Merges with stream

    */

    void Merge( CMceComMediaStream& aMergeWith );

#endif//MCE_COMMON_SERVER_SIDE

    /**

    * Gets empty sink

    * @return empty sink

    */

    CMceComMediaSink& EmptySinkL();

    /**

    * Gets empty source

    * @return empty source

    */