/*

* Copyright (c) 2004-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 __RTPMANAGER_H

#define __RTPMANAGER_H

#include <commdbconnpref.h>

#include <es_enum.h>

#include <rtpdef.h>

#include <rtpheader.h>

#include "rtpsession.h"

#include "rtpsdes.h"

#include "localaddrresolver.h"

#include "rtpmanagerdef.h"

#include "rtpasignuniqueid.h"

#include "srtpsession.h"

#include "rtpsessionsrtp.h"

/**

*  Container of all rtp sessions. 

*

*  @lib RtpService.dll

*/

class CRtpManager : public CBase,

    				public MRtpAsignUniqueID

    {

    #if defined( _DEBUG ) && defined( RTP_UNIT_TEST )

    // Friend class used for testing

        friend class CRtpUtRtpManager;

    #endif

    public: // Data types

        enum TCreateStreamType

            {

            ECreateRecvStream = 0,

            ECreateTranStream,

            ECreateTranStreamExt

            };

    public:

        static CRtpManager* NewL( MRtpErrNotify& aErrNotify );

        ~CRtpManager();

        TInt OpenL( const TRtpSdesParams& aSdesInfo, 

                    const TDesC* aRtpPacketDll, 

                    RSocketServ* aSocketServPtr,

                    RConnection* aRConnPtr );

        /**

        * Open and initialize the CRtpAPI object synchronously.

        * @param TInt aIapId - [input] IAP ID. If -1, no IAP selection dialog

        *   will pop up. Instead, the default IAP will be used.

        * @return TInt - KErrNone if successful; system wide error code

        *   otherwise

        */

        TInt StartConnection( TInt aIapId );

        /**

        * Open and initialize the CRtpAPI object in asynchronous mode

        * @param TRequestStatus& aStatus - [output] On completion, will contain

        *   a status code: KErrNone if successful; system wide error code

        *   otherwise.

        * @param TInt aIapId - [input] IAP ID. If -1, no IAP selection dialog

        *   will pop up. Instead, the default IAP will be used.

        * @return TInt - KErrNone if successful; system wide error code

        *   otherwise

        */

        TInt StartConnection( TRequestStatus& aStatus, TInt aIapId );

        /**

        * Cancels asynchoronous start of connection

        * Any open requests will be completed with KErrCancel.

        * @return None

        */

        void CancelStart(); 

        void Close( void );

        void SetLocalSdes( const TRtpSdesParams& aSdesInfo );

        TInetAddr& GetLocalIPAddressL();

        TRtpId CreateSessionL( const TCreateSessionParams& aSessionParams,

                               TUint& aPort,

                               TBool aEnableRtcp,

                               const TRtcpParams* aRtcpParams );

		TRtpId CreateSessionL( const TCreateSessionParams& aSessionParams,

                               TUint& aPort,

                               TBool aEnableRtcp,

                               const TRtcpParams* aRtcpParams,

                               CSRTPSession& aSRTPSession );

        TInt StartSession( TRtpId aSessionId );

        void CloseSession( TRtpId aSessionId );

        TInt SetRemoteAddress( TRtpId aSessionId, TInetAddr& aRemoteAddr );

        TInt SetRemoteRtcpAddress( TRtpId aSessionId, TInetAddr& aRemoteAddr );

        /**

        * Does the actual work of creating a stream. Used by the other

        * stream creation methods.

        * @return ID of the created stream, or KNullId if not successful

        */

        TRtpId CreateStreamL( TRtpId aSessionId,

                              const TCreateStreamType aStreamType,

                              TRtpPayloadType aPayloadType,

                              TRtpSSRC& aSSRC );

        TRtpId CreateReceiveStreamL( TRtpId aSessionId, const TRcvStreamParams& aParams );

        TRtpId CreateTransmitStreamL( TRtpId aSessionId, const TTranStreamParams& aParams, 

                                      TRtpSSRC& aSSRC );

        TRtpId CreateTransmitStreamExtL( TRtpId aSessionId, const TTranStreamParams& aParams, 

                                         const TRtpSSRC aSSRC );

        void CloseStream( TRtpId aStreamId );

        TInt RegisterRtpObserver( TRtpId aSessionId, MRtpObserver& aObserver );

        void UnregisterRtpObserver( TRtpId aSessionId );

        TInt SetNonRTPDataObserver( TRtpId aSessionId, 

                                    MNonRTPDataObserver* aNonRTPDataObserver );

        TInt SendRtpPacket( TRtpId aTranStreamId, 

                            const TRtpSendHeader& aHeaderInfo, 

                            const TDesC8& aPayloadData );

        TInt SendRtpPacket( TRtpId aTranStreamId,

                            const TRtpSendHeader& aHeaderInfo,

                            const TDesC8& aPayloadData,

                            TRequestStatus& aStatus );

        TInt SendRtpPacket( TRtpId aTranStreamId,

                            TRtpSequence aSequenceNum,

                            const TRtpSendHeader& aHeaderInfo,

                            const TDesC8& aPayloadData,

                            TRequestStatus& aStatus );

        void SendDataL( TRtpId aSessionId,

                       TBool aUseRTPSocket,

                       const TDesC8& aData,

                       TRequestStatus& aStatus );

        void CancelSend( TRtpId aSessionId );

        TInt RegisterRtcpObserver( TRtpId aSessionId, MRtcpObserver& aObserver );

        void UnregisterRtcpObserver( TRtpId aSessionId );

        TInt SendRtcpByePacketL( TRtpId aTranStreamId, const TDesC8& aReason );

        TInt SendRtcpAppPacketL( TRtpId aTranStreamId, const TRtcpApp& aApp );

        /**

        * Send an RTCP RR packet for a Reception stream.

        * @param TRtpId aRcvStreamId - [input] Reception stream ID

        * @return TInt - KErrNone if successful; system wide error code otherwise

        */

        TInt SendRtcpRrPacketL( TRtpId aRcvStreamId );

        /**

        * Send an RTCP SR packet for a Transmit stream.

        * @param TRtpId aTranStreamId - [input] Transmit stream ID

        * @return TInt - KErrNone if successful; system wide error code otherwise

        */

        TInt SendRtcpSrPacketL( TRtpId aTranStreamId );

        /**

        * Suspend RTCP sending on/off, calculations will continue. 

        * @param TRtpId aSessionId - [input] RTP Session ID

        * @param TBool aAutoSending - [input] Auto sending flag. 

        *							  ETrue:  RTCP sending will be scheduled normally

        *							  EFalse: RTCP sending will be suspended

        * @return TInt - KErrNone if successful; KErrNotFound if invalid session id;

        *				 KErrNotSupported if RTCP disabled;  system wide error code otherwise				

        */

        TInt SuspendRtcpSending( TRtpId aSessionId, TBool aAutoSending );

		/**

        * Gets the status of automatic RTCP sending.

        * @param TRtpId aSessionId - [input] RTP Session ID

        * @param TBool aAutoSending - [output] ETrue: RTCP atuo sending is on 

        *				  					   EFalse: RTCP auto sending is off

 		* @return TInt - KErrNone if successful; KErrNotFound if invalid session id;

        *				 KErrNotSupported if RTCP disabled;  system wide error code otherwise

        */

        TInt IsRtcpSendingSuspended( TRtpId aSessionId, TBool& aAutoSending );

        TRtpId GetSessionId( TRtpId aStreamId );

        RSocket* GetRtpSocket( TRtpId aSessionId );

        RSocket* GetRtcpSocket( TRtpId aSessionId );

        TInt GetStreamStatistics( TRtpId aStreamId, TRtpPeerStat& aStat );

        TUint32 GetSamplingRate( TUint8 aPayloadType );

        TInt SetSamplingRate( TUint8 aPayloadType, TUint32 aSampleRate );

        TInt SetRtcpParameters( TRtpId aSessionId, const TRtcpParams& aRtcpParams );

    private:

        CRtpManager( MRtpErrNotify& aErrNotify );

        void ConstructL( void );

        CRtpSession* GetSession( TRtpId aSessionId );

        TRtpId AssignUniqueID();

        TInt AddRtpObject( TArrayStore aArrayID );

        TInt FindRtpObject( const TRtpId aMagicKey, TUint& aSessionAddress );

        TInt RemoveRtpObject( const TRtpId aMagicKey, const TObjectType aObjectType );

        void RemoveRtpAllObjects();

        /*

        * Opens the socket server and the connection

        * @return KErrNone if successful, system error code otherwise

        */

        /*

        * @return Internet Access Point ID of iConn

        */

        TInt GetIapId( TUint32& aIapId );

        TInt AddStreamToSession(TRtpId aSessionId, TRtpId aStreamId);

        void CheckSdesCName();

    private:   // data

        TBool iStandardRtp;

        TBool iEnableRtcp;

        RLibrary iLibrary;

        RSocketServ iSocketServ;

        RConnection iConn;

        RSocketServ* iSocketServPtr;  // Don't use until future

        RConnection* iConnPtr;    // Don't use until future

        TBool iConnected;

		TInt iIapId;

        TInetAddr iLocalAddr;

        CRtpSDES* iDefaultSdes;

        TRtpId iNumOfObjects;   // count of session and participants IDs assigned

        CArrayFixFlat<TArrayStore>* iSessionArray;   //keep track of all RTP session;

        TUint32 iProfileRTPTimeRates[KRtpMaxPayloadTypes];

        MRtpErrNotify& iErrNotify;

    private:    

    #ifdef EUNIT_TESTING

	  friend class UT_CRtpAPI;

	  friend class UT_CRtpManager;

	#endif     	    

    };

#endif    // __RTPMANAGER_H

// End of File