/*

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

#define CMCESRVSTREAM_H

#include <e32base.h>

#include <mmccinterfacedef.h>

#include <in_sock.h>

#include "mcemediadefs.h"

#include "mcecommediastream.h"

#include "mcesrv.h"

class CMceComAudioStream;

class CMceComVideoStream;

class CMceSrvSource;

class CMceSrvSink;

class CMceSrvCodec;

class CMceComEndpoint;

class CMceComMediaSource;

class CMceComMediaSink;

class CMceComCodec;

class CMceMediaManager;

class TMceMccComEvent;

class CMccCodecInformation;

class CMccInterface;

class CMceDtmfHandler;

class CMceSrvEndpoint;

const TBool KMceSrvStreamCallback = ETrue;

const TBool KMceSrvStreamNoCallback = EFalse;

const TBool KMceSrvStreamDefaultSequence = EFalse;

const TBool KMceSrvStreamAlternativeSequence = ETrue;

const TBool KMceSrvStreamForce = ETrue;

const TBool KMceSrvStreamNoForce = EFalse;

const TBool KMceSrvStreamSync = ETrue;

const TBool KMceSrvStreamNoSync = EFalse;

/**

 * 

 *

 * @lib 

 */

class CMceSrvStream: public CBase

    {

public: // enums

    /**

    * Current state in MCC 

    */

    enum TState

        {

        EAdopted = 1,

        ECreated,

        ECreatingLink,

        ELinkCreated,

        EPreparing,

        EPrepared,

        EStarting,

        EPending,

        EStopped,

        EInactive,

        EStarted,

        EPausing,

        EPaused

        };

public: // Constructors & Destructor

    /**

    * Decodes stream to array of server streams.

    * This is factory method

    * @return array of server streams

    */

    static void DecodeL( RPointerArray<CMceSrvStream>& aStreams,

                         CMceComMediaStream& aStream,

                         CMceMediaManager& aManager );

    /**

    * Creates srv stream.

    */

    static CMceSrvStream* NewL( CMceMediaManager& aManager,

                                CMceComMediaStream& aData,

                                CMceComMediaSource& aSource,

                                CMceComMediaSink& aSink,

                                CMceComCodec& aCodec );

    /**

    * Destructor.

    */

     ~CMceSrvStream();

public: // static API

    static CMceSrvStream* EventReceived( 

                        RPointerArray<CMceSrvStream>& aStreams,

                        TMceMccComEvent& aEvent,

                        TBool aConsumeOnlyOnce = EFalse );

public: // virtual functions

    /**

    * Gets session id

    * @return session id

    */

    virtual TUint32 SessionId() const;

    /**

    * Gets link id

    * @return link id

    */

    virtual TUint32 LinkId() const;

    /**

    * Sets link id

    * @param aLinkId link id

    */

    virtual void SetLinkId( TUint32 aLinkId );

    /**

    * Gets IAP id

    * @return IAP id

    */

    virtual TUint32 IapId() const;

    /**

    * Gets local media port of stream

    * @return local media port of stream

    */

    virtual TUint LocalMediaPort() const;

    /**

    * Handles event from MCC

    * @return status of operation

    */

    virtual TInt EventReceived( TMceMccComEvent& aEvent, TBool aCallback = KMceSrvStreamCallback );

    /**

    * Cleans up unused sinks/sources from mcc

    */

    virtual void Cleanup();

    /**

    * Checks, if this is equal to another stream

    * @param aStream an another stream

    * @return ETrue, if this is equal

    */

    virtual TBool IsEqual( const CMceSrvStream& aStream ) const;

    /**

    * Merges with stream from cloned session

    */

    virtual void Merge( CMceSrvStream& aMergeWith, TBool aDeepMerge = EFalse );

    /**

    * UnMerges with stream from cloned session

    */

    void UnMergeL( CMceSrvStream& aUnMergeFrom );

    /**

    * Is Prepared by MCC

    * @return ETrue, if so

    */

    virtual TBool IsMccPrepared() const;

    /**

    * Returns state of stream, which depends on states of

    * sink and source

    * @return the state

    */

    virtual TState State() const;

    /**

    * Invalidates the stream

    */

    virtual void Invalidate();

    /**

    * Is adopted

    */

    virtual TBool IsAdopted() const;

public: // Data access etc

    /**

    * Sets local media port of stream

    * @param aPort local media

    */

    void SetLocalMediaPort( TUint aPort );

    /**

    * Gets id

    * @return id

    */

    TUint32& Id();

    /**

    * Gets stream type

    * @return stream type

    */

    CMceComMediaStream::TStreamType StreamType() const;

    /**

    * Gets direction

    * @return direction

    */

    CMceComMediaStream::TStreamType Direction() const;

    /**

    * Is Merged

    * @return ETrue, if merged

    */

    TBool IsMerged() const;

    /**

    * Gets the original com stream

    * @return the original com stream

    */

    CMceComMediaStream& Data() const;

    /**

    * Gets remote ip address

    * @return  remote ip address

    */

    TInetAddr RemoteIpAddress() const;

    /**

    * Gets codec of the mcc stream. 

    * @return codec of the mcc stream. 

    */

    CMceComCodec& Codec() const;

    /**

    * Gets source of the mcc stream.

    * @return source of the mcc stream.

    */

    CMceSrvSource& Source() const;

    /**

    * Gets sink of the mcc stream. 

    * @return sink of the mcc stream. 

    */

    CMceSrvSink& Sink() const;

    /**

    * Gets mcc stream type

    * @return mcc stream type

    */

    TInt MccStreamType() const;

    /**

    * Gets mcc link type

    * @return mcc link

    */

    TInt LinkType() const;

    /**

    * Checks, if received event matches

    * @param aEvent an event

    * @return ETrue, if there is a match

    */

    TBool Consumes( const TMceMccComEvent& aEvent ) const;

    /**

    * Returns dtmf handler for the stream.

    * @return dtmf handler

    */

    CMceDtmfHandler& DtmfHandlerL( CMccInterface& aMccInterface );

    /**

    * Updates sink/source's "is enabled" status.

    * @param aSinkAffected if sink status is changed

    * @param aSourceAffected if source status is changed

    * @param aIsEnabled

    */

    void UpdateEndpointStates( TBool aSinkAffected, 

                               TBool aSourceAffected, 

                               TBool aIsEnabled );

    /**

    * Checks whether stream is associated with certain endpoint.

    * @param aEndpoint search term

    * @param aUseProxyMatch

    */

    TBool EndpointMatch( const CMceComEndpoint& aEndpoint, 

                         TBool aUseProxyMatch );

public: // new 

    /**

    * Hook to allow stream to have alternative create link sequence

    * @return EFalse to indicate that normal link creation can 

    * take place. ETrue indicates that link creation is not needed

    */

    TBool CreateLinkL();

    /**

    * Hook to allow stream to have alternative preparation

    * @return EFalse to indicate that normal preparation can 

    * take place. ETrue indicates that stream has been prepared 

    * by itself

    */

    TBool PrepareL();

    /**

    * Hook to allow stream to have alternative starting

    * @return EFalse to indicate that normal starting can 

    * take place. ETrue indicates that stream has been started 

    * by itself

    */

    TBool StartL();

    /**

    * Hook to allow stream to have alternative updating

    * @return EFalse to indicate that normal updating can 

    * take place. ETrue indicates that stream has been updated 

    * by itself

    */

    TBool SynchronizeL();

    /**

    * Hook to allow stream to have alternative stopping

    * @return EFalse to indicate that normal stopping can 

    * take place. ETrue indicates that stream has been stopped 

    * by itself

    */

    TBool Stop();

    /**

    * Hook to allow stream to have alternative validation

    * @return EFalse to indicate that normal validation can 

    * take place. ETrue indicates that stream has been validated 

    * by itself

    */

    TBool Validate();

    /**

    * Called as a part of session unmerge

    */

    void UnMerge();

    /**

    * Checks if update requires signalling

    * @param aCurrent current stream, if NULL this is a new stream

    * @param aMccCurentCodec current codec, if NULL this is a new stream

    * @param aMccUpdateCodec codec based on update (this)

    * @return indication of signaling required

    */

    TInt RequireSignalling( CMceSrvStream& aCurrent,

                             CMccCodecInformation& aMccCurentCodec, 

                             CMccCodecInformation& aMccUpdateCodec ) const;

    /**

    * Called when new stream has beed detected in update

    * @param aUpdateStreams new streams from update

    * @return indication of signaling required

    */

    TInt RequireSignalling( RPointerArray<CMceSrvStream>& aUpdateStreams ) const;

    /**

    * Called after prepare is called for this

    * stream

    */

    void MccPrepareCalledL();

protected://CMcc

    /**

     * C++ default constructor.

     */

    CMceSrvStream();

    /**

     * C++ default constructor.

     */

    CMceSrvStream( CMceMediaManager* aManager,

                   CMceComMediaStream* aData,

                   CMceComCodec* aCodec );

    void ConstructL( CMceComMediaSource& aSource,

                     CMceComMediaSink& aSink );

private: // 

    static void DecodeAudioL( RPointerArray<CMceSrvStream>& aStreams,

                              CMceComAudioStream& aAudio,

                              CMceMediaManager& aManager );

    static void DecodeVideoL( RPointerArray<CMceSrvStream>& aStreams,

                              CMceComVideoStream& aVideo,

                              CMceMediaManager& aManager );

    TBool UseDefaultStartupSequence();

    TBool StreamStateChangeEventReceived( TMceMccComEvent& aEvent );

    void DoEndpointDisable( CMceSrvEndpoint& aEndpoint );

protected://not owned data

    CMceMediaManager* iManager;

protected: // owned data

    CMceSrvSource* iSource;

    CMceSrvSink* iSink;

    CMceComMediaStream* iData;

    CMceComCodec* iCodec;

    TBool iMerged;

    CMceDtmfHandler* iDtmfHandler;

protected: // NOT owned data

    TUint32 iID;

    friend class CMceAdoptedSrvStream;

	//definitions for unit testing

	MCEMM_UT_DEFINITIONS

    };

#endif //CMCESRVSTREAM_H