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