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




#include "mcertpsource.h"
#include "mcesession.h"
#include "mcemanager.h"
#include "mcemediastream.h"
#include "mcertpobserver.h"
#include "mcecomrtpsource.h"
#include "mceitcsender.h"
#include "mceevents.h"
#include "mceserial.h"
#include "mceclilogs.h"


#define KMCETIMERDISABLED 0
#define _FLAT_DATA static_cast<CMceComRtpSource*>( iFlatData )
#define FLAT_DATA( data ) _FLAT_DATA->data


// ============================ MEMBER FUNCTIONS ===============================


// -----------------------------------------------------------------------------
// CMceRtpSource::NewL
// -----------------------------------------------------------------------------
//
EXPORT_C CMceRtpSource* CMceRtpSource::NewL(
					   TUint aBufferLength,
					   TUint aBufferTreshold,
					   TUint32 aInactivityTimer,
					   HBufC8* aIdentity )
    {
    CMceRtpSource* self = NewLC( aBufferLength, aBufferTreshold,
    	 aInactivityTimer, aIdentity );
    CleanupStack::Pop( self );
    return self;   
    }

// -----------------------------------------------------------------------------
// CMceRtpSource::NewLC
// -----------------------------------------------------------------------------
//
EXPORT_C CMceRtpSource* CMceRtpSource::NewLC(
					   TUint aBufferLength,
					   TUint aBufferTreshold,
					   TUint32 aInactivityTimer,
					   HBufC8* aIdentity )
    {
    CMceRtpSource* self = new (ELeave) CMceRtpSource();
    CleanupStack::PushL( self );
    self->ConstructL( aBufferLength, aBufferTreshold, 
                      aInactivityTimer, NULL, aIdentity );
    return self;
    }


// -----------------------------------------------------------------------------
// CMceRtpSource::~CMceRtpSource
// -----------------------------------------------------------------------------
//
EXPORT_C CMceRtpSource::~CMceRtpSource()
    {
    }

// -----------------------------------------------------------------------------
// CMceRtpSource::EnableL
// -----------------------------------------------------------------------------
//
EXPORT_C void CMceRtpSource::EnableL() 
    {
    MCECLI_DEBUG("CMceRtpSource::EnableL, Entry");
    
    CMceMediaSource::DoEnableL();

    MCECLI_DEBUG("CMceRtpSource::EnableL, Exit");
    
    }

// -----------------------------------------------------------------------------
// CMceRtpSource::DisableL
// -----------------------------------------------------------------------------
//
EXPORT_C void CMceRtpSource::DisableL() 
    {
    MCECLI_DEBUG("CMceRtpSource::DisableL, Entry");
    
    CMceMediaSource::DoDisableL();
    
    MCECLI_DEBUG("CMceRtpSource::DisableL, Exit");
    
    }


// -----------------------------------------------------------------------------
// CMceRtpSource::EnableInactivityTimerL
// -----------------------------------------------------------------------------
//
EXPORT_C void CMceRtpSource::EnableInactivityTimerL( TUint32 aInactivityTimer ) 
    {
    MCECLI_DEBUG("CMceRtpSource::EnableInactivityTimerL, Entry");
    MCECLI_DEBUG_DVALUE("timer", aInactivityTimer );
    
    __ASSERT_ALWAYS( MCE_ENDPOINT_ITC_ALLOWED( *this ), 
        User::Leave( KErrNotReady ) );
    if ( MCE_ENDPOINT_ITC_ALLOWED( *this ) )
        {
        CMceSession* session = iStream->Session();

        TMceIds ids;
        session->PrepareForITC( ids );
        ids.iMediaID = iStream->Id();
        ids.iSourceID  = Id();
        
        TMceItcArgTUint32 inactivity( aInactivityTimer );
        session->ITCSender().WriteL( ids, EMceItcEnableInactivityTimer, inactivity );
        }
    MCECLI_DEBUG("CMceRtpSource::EnableInactivityTimerL, Exit");
        
    }

// -----------------------------------------------------------------------------
// CMceRtpSource::DisableInactivityTimer
// -----------------------------------------------------------------------------
//
EXPORT_C void CMceRtpSource::DisableInactivityTimerL() 
    {
    MCECLI_DEBUG("CMceRtpSource::DisableInactivityTimerL, Entry");
    
    FLAT_DATA( iInactivityTimer ) = KMCETIMERDISABLED;

    if ( MCE_ENDPOINT_ITC_ALLOWED( *this ) )
        {
        DoITCSendL( EMceItcDisableInactivityTimer );    
        }
    MCECLI_DEBUG("CMceRtpSource::DisableInactivityTimerL, Exit");
    
    }

// -----------------------------------------------------------------------------
// CMceRtpSource::UpdateL
// -----------------------------------------------------------------------------
//
EXPORT_C void CMceRtpSource::UpdateL ( TUint aBufferLength,
								TUint aBufferTreshold,
								TUint32 aInactivityTimer,
								HBufC8* aIdentity )
	{
    MCECLI_DEBUG("CMceRtpSource::UpdateL, Entry");
    MCECLI_DEBUG_DVALUE("buffer length", aBufferLength );
    MCECLI_DEBUG_DVALUE("buffer treshold", aBufferTreshold );
    MCECLI_DEBUG_DVALUE("inactivity timer", aInactivityTimer );
	
    FLAT_DATA( iInactivityTimer ) = aInactivityTimer;
    FLAT_DATA( iBufferLength ) = aBufferLength;
    FLAT_DATA( iBufferTreshold ) = aBufferTreshold;
    MCE_DELETE( FLAT_DATA( iTalkBurstIndicator ) );
    FLAT_DATA( iTalkBurstIndicator ) = 0;
    MCE_DELETE( FLAT_DATA( iIdentity ) );
    FLAT_DATA( iIdentity ) = aIdentity ? aIdentity->AllocL() : NULL;

    MCECLI_DEBUG("CMceRtpSource::UpdateL, Exit");
	}

// -----------------------------------------------------------------------------
// CMceRtpSource::SendRRL
// -----------------------------------------------------------------------------
//
EXPORT_C void CMceRtpSource::SendRRL() 
    {
    MCECLI_DEBUG("CMceRtpSource::SendRRL, Entry");
    
    __ASSERT_ALWAYS( MCE_ENDPOINT_ITC_ALLOWED( *this ), 
                     User::Leave( KErrNotReady ) );
    
    DoITCSendL( EMceItcSendRR );
    
    MCECLI_DEBUG("CMceRtpSource::SendRRL, Exit");
    }

// -----------------------------------------------------------------------------
// CMceRtpSource::Ssrc
// -----------------------------------------------------------------------------
//
EXPORT_C TUint32 CMceRtpSource::Ssrc() const
    {
    return 0;
    }
    
// -----------------------------------------------------------------------------
// CMceRtpSource::Ssrcs
// -----------------------------------------------------------------------------
//
EXPORT_C const RArray<TUint>& CMceRtpSource::Ssrcs() const			
    {
    return FLAT_DATA( iNotSupported );    
    }

// -----------------------------------------------------------------------------
// CMceRtpSource::EnableSsrcL
// -----------------------------------------------------------------------------
//
EXPORT_C void CMceRtpSource::EnableSsrcL( TUint /*aSsrc*/ )
    {
    User::Leave( KErrNotSupported );
    }

// -----------------------------------------------------------------------------
// CMceRtpSource::DisableSsrcL
// -----------------------------------------------------------------------------
//
EXPORT_C void CMceRtpSource::DisableSsrcL( TUint /*aSsrc*/ )
    {
    User::Leave( KErrNotSupported );
    }

// -----------------------------------------------------------------------------
// CMceRtpSource::IsSsrcEnabledL
// -----------------------------------------------------------------------------
//
EXPORT_C TBool CMceRtpSource::IsSsrcEnabledL( TUint /*aSsrc*/ )
    {
    User::Leave( KErrNotSupported );
    return EFalse;
    }
	
// -----------------------------------------------------------------------------
// CMceRtpSource::CMceRtpSource
// -----------------------------------------------------------------------------
//
CMceRtpSource::CMceRtpSource()
   : CMceMediaSource()
    {
    }


// -----------------------------------------------------------------------------
// CMceRtpSource::ConstructL
// -----------------------------------------------------------------------------
//
void CMceRtpSource::ConstructL( TUint aBufferLength,
                                TUint aBufferTreshold,
                                TUint32 aInactivityTimer,
                                HBufC8* aTalkBurstIndicator,
                                HBufC8* aIdentity )
    {
    CMceComRtpSource* source = CMceComRtpSource::NewLC();
    CMceMediaSource::ConstructL( source );
    CleanupStack::Pop( source );
    
    FLAT_DATA( iInactivityTimer ) = aInactivityTimer;
    FLAT_DATA( iBufferLength ) = aBufferLength;
    FLAT_DATA( iBufferTreshold ) = aBufferTreshold;
    FLAT_DATA( iTalkBurstIndicator ) = aTalkBurstIndicator;
    FLAT_DATA( iIdentity ) = aIdentity ? aIdentity->AllocL() : NULL;
    }



// -----------------------------------------------------------------------------
// CMceRtpSource::EventReceivedL
// -----------------------------------------------------------------------------
//
TInt CMceRtpSource::EventReceivedL( TMceEvent& aEvent )
    {
    TInt status = CMceMediaSource::EventReceivedL( aEvent );
    if ( status != KMceEventNotConsumed )
        {
        return status;
        }
                
    if ( aEvent.Id().IsSourceId() )
        {
        status = HandleEvent( aEvent );
        }
    else
        {
        status = KMceEventNotConsumed;
        }
    
    return status;
    
    }




// -----------------------------------------------------------------------------
// CMceRtpSource::HandleEvent
// -----------------------------------------------------------------------------
//
TInt CMceRtpSource::HandleEvent( TMceEvent& aEvent )
    {
    MCECLI_DEBUG("CMceRtpSource::HandleEvent, Entry");
    
    TInt status = KMceEventNotConsumed;
    
    MMceRtpObserver* observer = iStream->Session()->Manager().RtpObserver();
    switch ( aEvent.Action() )
        {
        case EMceItcSRReceived:
            {
            MCECLI_DEBUG("CMceRtpSource::HandleEvent, SR received");
            if ( observer )
                {
                observer->SRReceived( *( iStream->Session() ), *iStream );
                }
            status = KMceEventConsumed;
            break;
            }
        case EMceItcRRReceived:
            {
            MCECLI_DEBUG("CMceRtpSource::HandleEvent, RR received");
            if ( observer )
                {
                observer->RRReceived( *( iStream->Session() ), *iStream );
                }
            status = KMceEventConsumed;
            break;
            }
        case EMceItcInactivityTimeout:
            {
            MCECLI_DEBUG("CMceRtpSource::HandleEvent, inactivity timeout received");
            if ( observer )
                {
                observer->InactivityTimeout( *iStream, *this );
                }
            status = KMceEventConsumed;
            break;
            }
        default:
            {
            //NOP
            MCECLI_DEBUG("CMceRtpSource::HandleEvent, not consumed");
            break;
            }
        
        }
    
    MCECLI_DEBUG_DVALUE("CMceRtpSource::HandleEvent, Exit. status", status );
    return status;
    
    }
    
// -----------------------------------------------------------------------------
// CMceRtpSource::DoITCSendL
// -----------------------------------------------------------------------------
//
void CMceRtpSource::DoITCSendL( TUint8 aITCFunction )
	{
    __ASSERT_ALWAYS( iStream, User::Leave( KErrNotReady ) );
    __ASSERT_ALWAYS( iStream->Session(), User::Leave( KErrNotReady ) );
    CMceSession* session = iStream->Session();
    
    if ( session->State() != CMceSession::EIdle )
        {
    	TMceIds ids;
    	session->PrepareForITC( ids );
    	ids.iMediaID   = iStream->Id();
	    ids.iSourceID  = Id();
    	ids.iState     = IsEnabled();
    	
        session->ITCSender().SendL( ids, static_cast<TMceItcFunctions>( aITCFunction ) );        
        }	
	}