/*
* 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
	*/
	TBool RemoteRTCPAddressChanged( TUint aNewPort, TInetAddr aAddr );
    
		
	/**
    * 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
    */
    CMceComMediaSource& EmptySourceL();
    

    /**
    * Checks whether RTCP should be used.
    * return ETrue, if the source and all the sinks indicate RTCP usage,
    *        otherwise EFalse. 
    */
    TBool UseRtcp() const;

protected:


    /**
     * C++ default constructor.
     * @param type of stream
     */
	CMceComMediaStream( TMceMediaType aType );

    /**
    * second-phase constructor
    */
	void ConstructL();
	
    /**
     * second-phase copy constructor
     */
	void ConstructL( CMceComMediaStream& aStream );
	

private: // methods

    /**
    * one-way bind
    * @param aStream another stream to be bind to the stream.
    */
    void DoBind( CMceComMediaStream* aStream );    
    
    /**
    * Deletes source
    */
	void DeleteSource();
	
	/**
    * Checks whether RTCP should be used.
    * return ETrue, if the source and all the sinks indicate RTCP usage,
    *        otherwise EFalse. 
    */
	TBool DoUseRtcp() const;

public: // Owned serialized Data

    /**
     * ID
     */
    TMceMediaId iID;

    /**
     * type
     */
    TMceMediaType iType;
    
    /**
     * state, enabled or disabled
     */
    TBool iIsEnabled;
    
	/**
    * Local port
    */
	TUint iLocalMediaPort;

	/**
    * Remote port
    */
	TUint iRemoteMediaPort;
    
    /**
    * Remote RTCP IP-address (IPv4 or IPv6)
    */    
    TInetAddr iRemoteRtcpAddress;
    
    /**
    * Remote RTCP port, if 0 then use RTP port + 1
    */
	TUint iRemoteRtcpPort;
	
    /**
     * local sdp media lines
     */
    CDesC8Array* iLocalMediaSDPLines;

    /**
     * remote sdp media lines
     */
    CDesC8Array* iRemoteMediaSDPLines;

    /**
     * stream type
     */
    TStreamType iStreamType;
    
    /**
     * stream state
     */
    CMceMediaStream::TState iState;
    
    /**
    * ignore remote port comparison
    */
    TBool iIgnoreRemotePort;

    /**
     * does this owns the link
     */
    TBool iLinkOwner;

    /**
     * linked stream. Owned if iLinkOwner is ETrue
     */
    CMceComMediaStream* iLinkedStream;
    
    /**
     * source
     */
	CMceComMediaSource* iSource;
	
    /**
     * sinks
     */
	RPointerArray<CMceComMediaSink> iSinks;

    /**
     * sdp index
     */
    TInt iSdpIndex;
    
    /**
     * link id
     */
    TUint32 iLinkId;
    
    /**
     * preconditions
     */
    RPointerArray <TMcePreconditions> iPreconditions;
    
    /**
     * empty source
     */
    CMceComMediaSource* iEmptySource;
    
    /**
     * empty sink
     */
    CMceComMediaSink* iEmptySink;
    
    
protected: // NOT owned data
	
    /**
     * session
     */
	CMceComSession* iSession;

private:

    TBool iDowngradedEnpoints;

#ifdef EUNIT_TEST
	friend class UT_CMceMediaSdpCodec;
    friend class UT_CMceAudioSdpCodec;
    friend class UT_CMceVideoSdpCodec;

#endif    
	};


#endif