/*
* Copyright (c) 2008 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:  Provides RTP observation class
*
*/


#include <mcemediastream.h>
#include <mceaudiostream.h>
#include <mceaudiocodec.h>
#include "svprtpobserverrequest.h"
#include "svpsessionbase.h"
#include "svptimer.h"
#include "svpconsts.h"
#include "mccpcallobserver.h"
#include "svplogger.h"
#include "svpholdcontroller.h"

// LOCAL CONSTANTS
// RTCP timeout interval, 30 seconds.
const TInt KSVPRtcpTimeout = 30000;
// Drift 5 seconds, added to actual timeout allowing some randomness in
// actual timeout.
const TInt KSVPRtcpTimeoutDrift = 5000;

// ---------------------------------------------------------------------------
// CSVPRtpObserverRequest::CSVPRtpObserverRequest
// ---------------------------------------------------------------------------
//
CSVPRtpObserverRequest::CSVPRtpObserverRequest(
    CSVPSessionBase& aSession  ) : iSession( aSession )
    {
    // No implementation required
    }

// ---------------------------------------------------------------------------
// CSVPRtpObserverRequest::~CSVPRtpObserverRequest
// ---------------------------------------------------------------------------
//
CSVPRtpObserverRequest::~CSVPRtpObserverRequest()
    {
    delete iTimer;
    }

// ---------------------------------------------------------------------------
// CSVPRtpObserverRequest::NewLC
// ---------------------------------------------------------------------------
//
CSVPRtpObserverRequest* CSVPRtpObserverRequest::NewLC(
    CSVPSessionBase& aSession )
    {
    CSVPRtpObserverRequest* self =
        new ( ELeave ) CSVPRtpObserverRequest( aSession );
    
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
    }

// ---------------------------------------------------------------------------
// CSVPRtpObserverRequest::NewL
// ---------------------------------------------------------------------------
//
CSVPRtpObserverRequest* CSVPRtpObserverRequest::NewL(
    CSVPSessionBase& aSession )
    {
    CSVPRtpObserverRequest* self = CSVPRtpObserverRequest::NewLC( aSession );
    CleanupStack::Pop( self );
    return self;
    }

// ---------------------------------------------------------------------------
// CSVPRtpObserverRequest::ConstructL
// ---------------------------------------------------------------------------
//
void CSVPRtpObserverRequest::ConstructL()
    {
    // NB, no need for a special timer ID.
    iTimer = CSVPTimer::NewL( *this, KErrNone );
    }

// ---------------------------------------------------------------------------
// CSVPRtpObserverRequest::SvpSession
// ---------------------------------------------------------------------------
//
const CSVPSessionBase* CSVPRtpObserverRequest::SvpSession() const
    {
    return &iSession;
    }

// ---------------------------------------------------------------------------
// CSVPRtpObserverRequest::MceSession
// ---------------------------------------------------------------------------
//
const CMceSession* CSVPRtpObserverRequest::MceSession() const
    {
    return &( iSession.Session() );
    }

// ---------------------------------------------------------------------------
// CSVPRtpObserverRequest::RtcpPacketReceived
// ---------------------------------------------------------------------------
//
void CSVPRtpObserverRequest::RtcpPacketReceived(
    TReceivedRtcpPacket /*aPacket*/,
    CMceSession& aSession, 
    CMceMediaStream& aStream )
    {
    SVPDEBUG2( "CSVPRtpObserverRequest::RtcpPacketReceived aStream.IsEnabled: %d",
        aStream.IsEnabled() )
    SVPDEBUG2( "CSVPRtpObserverRequest::RtcpPacketReceived aSession: 0x%x",
        &aSession )
    SVPDEBUG2( "CSVPRtpObserverRequest::RtcpPacketReceived iSession: 0x%x",
        &( iSession.Session() ) )
    
    // Check that the given session matches ours
    if ( &aSession == &( iSession.Session() ) )
        {
        SVPDEBUG1( "CSVPRtpObserverRequest::RtcpPacketReceived, (re)start timer" )
        
        // For the sake of "just to be sure", stop the timer first
        const TInt timeout( DetermineTimeoutValue( aStream ) );
        iTimer->Stop();
        iTimer->SetTime( timeout );
        iDisconnectSent = EFalse;
        }
    }

// ---------------------------------------------------------------------------
// CSVPRtpObserverRequest::Reset
// ---------------------------------------------------------------------------
//
void CSVPRtpObserverRequest::Reset()
    {
    SVPDEBUG1( "CSVPRtpObserverRequest::Reset" )
    
    iTimer->Stop();
    }

// ---------------------------------------------------------------------------
// CSVPRtpObserverRequest::TimedOut
// ---------------------------------------------------------------------------
//
void CSVPRtpObserverRequest::TimedOut( TInt /*aTimerId*/ )
    {
    // For the sake of "just to be sure", stop the timer first
    iTimer->Stop();
    
    if ( IsSessionInHoldState() )
        {
        SVPDEBUG1( "CSVPRtpObserverRequest::TimedOut, (re)start timer because Session is on HOLD" )
        iTimer->SetTime( KSVPRtcpTimeout );
        iDisconnectSent = EFalse;
        }
    else
        {
        SVPDEBUG2( "CSVPRtpObserverRequest::TimedOut iDisconnectSent: %d",
            iDisconnectSent )
        
        // First CCE must be notified about 'disconnecting', state. Then timer is
        // re-started so that CCE & UI can handle the events with time (i.e user
        // has actually time to see the UI notifications).
        // After timer has fired second time, then send 'idle' event to the
        // CCE.
        
        
        if ( !iDisconnectSent )
            {
            iSession.GetCCPSessionObserver().CallStateChanged(
                MCCPCallObserver::ECCPStateDisconnecting, &iSession ); 
            
            iTimer->SetTime( KSVPTerminatingTime );
            iDisconnectSent = ETrue;
            }
        else
            {
            iSession.GetCCPSessionObserver().CallStateChanged(
                MCCPCallObserver::ECCPStateIdle, &iSession ); 
            }
        }
    }

// ---------------------------------------------------------------------------
// CSVPRtpObserverRequest::DetermineTimeoutValue
// ---------------------------------------------------------------------------
//
TInt CSVPRtpObserverRequest::DetermineTimeoutValue(
    CMceMediaStream& aStream ) const
    {
    // NB: aStream is not const because call to Codecs() is not const => this
    // saves a const_cast and keeps some sanity in casting. Though, we do not
    // modify anything in given aStream...
    
    TInt timeout( KSVPRtcpTimeout );
    if ( KMceAudio == aStream.Type() )
        {
        CMceAudioStream& audio( static_cast<CMceAudioStream&>( aStream ) );
        
        const RPointerArray<CMceAudioCodec>& codecs( audio.Codecs() );
        const TInt count = codecs.Count();
        for( TInt k = 0; k < count; k++ )
            {
            // MCE API talks about ms' but returns somethings that look awfully
            // close to seconds... Oh, well...
            const TInt kpval(
                codecs[k]->KeepAliveTimer() * KSVPMilliSecondCoefficient );
            if ( kpval > timeout )
                {
                timeout = kpval;
                }
                
            SVPDEBUG2( "CSVPRtpObserverRequest::DetermineTimeoutValue k: %d", k )
            SVPDEBUG2( "CSVPRtpObserverRequest::DetermineTimeoutValue kpval: %d", kpval )
            }
            
        SVPDEBUG2( "CSVPRtpObserverRequest::DetermineTimeoutValue count: %d", count )
        }
    
    // Now add the drifting to the timeout.
    timeout += KSVPRtcpTimeoutDrift;
    
    SVPDEBUG2( "CSVPRtpObserverRequest::DetermineTimeoutValue timeout: %d", timeout )
    
    return timeout;
    }

// ---------------------------------------------------------------------------
// CSVPRtpObserverRequest::IsSessionInHoldState
// ---------------------------------------------------------------------------
//
TBool CSVPRtpObserverRequest::IsSessionInHoldState()
    {
    if ( SvpSession()->HasHoldController() &&
            ESVPOnHold == (SvpSession()->HoldController()).HoldState() )
        {
        SVPDEBUG1( "CSVPRtpObserverRequest::IsSessionInHoldState ETrue" )
        return ETrue;
        }
    else
        {
        SVPDEBUG1( "CSVPRtpObserverRequest::IsSessionInHoldState EFalse" )
        return EFalse;
        }
    }