/*

* Copyright (c) 2006-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:  Session base class for SVP MO and MT sessions. Contains methods 

*                common for SVP MO and MT sessions.

*

*/

#include <e32math.h>

#include <escapeutils.h>

#include <mcetransactiondatacontainer.h>

#include <mceaudiostream.h>

#include <mcertpsink.h>

#include <mcertpsource.h>

#include <mceaudiocodec.h>

#include <mcedefs.h>

#include <mcesecuresession.h> 

#include <mcesecureoutsession.h>

#include <mcesecureinsession.h>

#include <mcemicsource.h>

#include <mcespeakersink.h>

#include <siperr.h>

#include <telephonydomainpskeys.h> // for mute 

#include "svpsessionbase.h"

#include "svpholdcontroller.h"

#include "svptransfercontroller.h"

#include "svptransferstatecontext.h"

#include "svptimer.h"

#include "svpsipconsts.h"

#include "svpuriparser.h"

#include "svpaudioutility.h"

#include "svpvolumeobserver.h"

#include "svplogger.h"

#include "svputility.h"

#include "svprtpobserver.h"

#include "svppropertywatch.h"

#include "svpdtmfeventgenerator.h"

// Local Consts

const TInt KMaxTimerValueMO = 4000;

const TInt KMinTimerValueMO = 2100;

const TInt KMaxTimerValueMT = 2000;

const TInt KMinTimerValueMT = 10;

const TInt KRandomDividerOne = 1000000;

const TInt KRandomDividerTwo = 1000;

const TInt KMaxPhoneVolume = 10;

// ---------------------------------------------------------------------------

// CSVPSessionBase::CSVPSessionBase

// ---------------------------------------------------------------------------

//

CSVPSessionBase::CSVPSessionBase( TMceTransactionDataContainer& aContainer,

    MSVPSessionObserver& aObserver, CSVPUtility& aSVPUtility,

    CSVPRtpObserver& aRtpObserver ) :

    iSVPUtility( aSVPUtility ),

    iRtpObserver( aRtpObserver ),

    iContainer( aContainer ),

    iObserver( aObserver ),

    iErrorInULandDLFirstTime ( ETrue ),

    iEarlyMediaOngoing ( EFalse )

    {

    }

// ---------------------------------------------------------------------------

// CSVPSessionBase::~CSVPSessionBase

// ---------------------------------------------------------------------------

//

CSVPSessionBase::~CSVPSessionBase()

    {

    SVPDEBUG1( "SVPSessionBase::~CSVPSessionBase In" )

    delete iCallParameters;

    delete iHoldController;

    iObserver.RemoveFromArray( *this );

    delete iSession;

    StopTimers();

    iTimers.Close();

    delete iRecipient;

    delete iDisplayName;

    delete iTransferController;

    delete iMutePropertyWatch;

    delete iVolObserver;

    delete iFromHeader;

    delete iToHeader;

    delete iCallId;

    delete iCSeqHeader;

    delete iEventGenerator;

    delete (iTempSecSession != iSession ? iTempSecSession : NULL );

    delete iDtmfString;

    SVPDEBUG1( "CSVPSessionBase::~CSVPSessionBase Out" )

    }

// ---------------------------------------------------------------------------

// CSVPSessionBase::ReleaseTempSecure

// ---------------------------------------------------------------------------

//

void CSVPSessionBase::ReleaseTempSecure()

    {

    delete iTempSecSession;

    iTempSecSession = NULL;

    }

// ---------------------------------------------------------------------------

// CSVPSessionBase::Session

// ---------------------------------------------------------------------------

//

const CMceSession& CSVPSessionBase::Session() const   

    {

    return *iSession;

    }

// ---------------------------------------------------------------------------

// CSVPSessionBase::StartTimerL

// ---------------------------------------------------------------------------

//

void CSVPSessionBase::StartTimerL( TInt aMilliSeconds, TInt aTimerId )

    {

    SVPDEBUG1( "CSVPSessionBase::StartTimerL In" )

    CSVPTimer* timer = CSVPTimer::NewL( *this, aTimerId );

    CleanupStack::PushL( timer );

    timer->SetTime( aMilliSeconds );

    iTimers.AppendL( timer );

    CleanupStack::Pop( timer );

    SVPDEBUG1( "CSVPSessionBase::StartTimerL Out" )

    }

// ---------------------------------------------------------------------------

// CSVPSessionBase::StopTimers

// ---------------------------------------------------------------------------

//

void CSVPSessionBase::StopTimers()

    {

    SVPDEBUG1( "CSVPSessionBase::StopTimers In" )

    while ( iTimers.Count() )

        {

        iTimers[0]->Stop();

        delete iTimers[0];

        iTimers.Remove( 0 );

        }

    SVPDEBUG1( "CSVPSessionBase::StopTimers Out" )

    }

// ---------------------------------------------------------------------------

// CSVPSessionBase::ReinviteCrossoverTime

// ---------------------------------------------------------------------------

//

TInt CSVPSessionBase::ReinviteCrossoverTime()

    {

    SVPDEBUG1( "CSVPSessionBase::ReinviteCrossoverTime In" )

    TInt maxValue( 0 );

    TInt minValue( 0 );

    if ( IsMobileOriginated() )

        {

        minValue = KMinTimerValueMO;

        maxValue = KMaxTimerValueMO;

        }

    else

        {

        minValue = KMinTimerValueMT;

        maxValue = KMaxTimerValueMT; 

        }

    TInt timerValue( 0 );

    TTime time;

    time.HomeTime();

    TInt64 seed( time.Int64() );

    for ( TInt i = 0; i < ( maxValue - minValue ); i++ )

        {

        TInt random = Math::Rand( seed );

        TReal random2 =  ( TReal )random / KRandomDividerOne;

        TInt random3 = ( TInt )( minValue * random2 ) / KRandomDividerTwo;

        if ( minValue <= random3 && minValue >= random3 )

            {

            timerValue = random3;

            break;

            }

        }

    SVPDEBUG2("CSVPSessionBase::ReinviteCrossoverTime Out return: %d", timerValue )

    return timerValue;    

    }

// ---------------------------------------------------------------------------

// CSVPSessionBase::StopTimer

// ---------------------------------------------------------------------------

//

void CSVPSessionBase::StopTimer( TInt aTimerId )

    {

    SVPDEBUG2( "CSVPSessionBase::StopTimer In, Timer -- ID: %d", aTimerId )

    // Find the timer and delete it.

    for ( TInt t = 0; t < iTimers.Count(); )

        {

        if ( iTimers[ t ] ->Id() == aTimerId )

            {

            iTimers[t]->Stop();

            delete iTimers[ t ];

            iTimers.Remove( t );

            }

        else

            {

            t++;

            }

        }

    SVPDEBUG1( "CSVPSessionBase::StopTimer Out" )

    }

// ---------------------------------------------------------------------------

// CSVPSessionBase::TimedOut

// ---------------------------------------------------------------------------

//    

void CSVPSessionBase::TimedOut( TInt aTimerId )

    {

    SVPDEBUG1( "CSVPSessionBase::TimedOut In" )

    // Find the timer and delete it.

    for ( TInt t = 0; t < iTimers.Count(); )

        {

        if ( iTimers[ t ] ->Id() == aTimerId )

            {

            delete iTimers[ t ];

            iTimers.Remove( t );

            }

        else

            {

            t++;

            }

        }

    if ( KSVPInviteTimerExpired == aTimerId )

        {

        // INVITE timer expired, notify client

        SVPDEBUG1( "CSVPSessionBase::TimedOut Invite timer expired, callback" )

        ExecCbErrorOccurred( ECCPErrorNotResponding );

        // send cancel

        TRAPD( errCancel, static_cast< CMceOutSession* >( iSession )->CancelL() );

        if ( errCancel )

            {

            SVPDEBUG2( "CSVPSessionBase::TimedOut Cancel: %d", errCancel )

            }

        ExecCbCallStateChanged( MCCPCallObserver::ECCPStateDisconnecting );

        TRAPD( errTimer, StartTimerL( KSVPTerminatingTime, KSVPRemoteEndDiedExpired ));

	    if ( errTimer )

		    {

			SVPDEBUG2("CSVPSessionBase::No Answer timer leave with error code %d",

			        errTimer )

            }

        }

    if ( KSVPTerminationTimerExpired == aTimerId )

        {

        // Renew terminating timer to keep session alive when incoming 

        // transfer ongoing, not longer than max default expire time (120s)

        if ( IsIncomingTransfer() &&

             !IsAttended() &&

             iTerminatingRepeat < KSVPDefaultExpiresTime )

            {

            SVPDEBUG2( "CSVPSessionBase::TimedOut UnAtte case iTerminatingRepeat = %d",

                iTerminatingRepeat )

            // Continue timeout time if the new session of the 

            // incoming transfer not yet established

            iTerminatingRepeat = iTerminatingRepeat +

                KSVPTerminatingTime / KSVPMilliSecondCoefficient;

            TRAPD( errTimer, StartTimerL( KSVPTerminatingTime,

                    KSVPTerminationTimerExpired ) );

            if ( errTimer )

                {

                SVPDEBUG2( "CSVPSessionBase::TimedOut Termination leave with code %d",

                        errTimer )

                }

            }

        else

            {

            SVPDEBUG1( "CSVPSessionBase::TimedOut Termination timer, callback" )

            ExecCbCallStateChanged( MCCPCallObserver::ECCPStateIdle );

            }

        }

    if ( KSVPRemoteEndDiedExpired == aTimerId )    

        {

        SVPDEBUG1( "CSVPSessionBase::TimedOut remote end died, callback" )

        // disconnecting state callback sent before timer started

        ExecCbCallStateChanged( MCCPCallObserver::ECCPStateIdle );

        }

    if ( KSVPHangUpTimerExpired == aTimerId )    

        {

        SVPDEBUG1( "CSVPSessionBase::TimedOut HangUp timer expired, callback" )

        // disconnecting state callback sent before timer started

        ExecCbCallStateChanged( MCCPCallObserver::ECCPStateIdle );

        }

    if ( KSVPExpiresTimeExpired == aTimerId )

        {

        SVPDEBUG1( "CSVPSessionBase::TimedOut expires timer expired" )

        // send 487

        TRAPD( err, static_cast<CMceInSession*>( iSession )->RespondL(

                KSVPRequestTerminatedReason, KSVPRequestTerminatedVal ) );

        if ( err )

            {

            // sending response failed

            // not serious because session is put to idle state anyway

            }

        // event is needed in upper level for correct bubble and log handling

        ExecCbCallEventOccurred( MCCPCallObserver::ECCPRemoteTerminated );

        // idle can be sent directly without disconnecting state

        ExecCbCallStateChanged( MCCPCallObserver::ECCPStateIdle );

        }

    if ( KSVPHoldTimerExpired == aTimerId ||

         KSVPResumeTimerExpired == aTimerId )

        {

        if ( iHoldController )

            {

            SVPDEBUG1( "CSVPSessionBase::TimedOut - Hold/Resume request Expired" )

            iHoldController->TimedOut();

            TInt contErr = iHoldController->ContinueHoldProcessing( *iSession );

            if ( KSVPResumeTimerExpired == aTimerId &&

                 CMceSession::EEstablished == iSession->State() )

                {

                // MCE state error prevents cancelling session; go to terminating

                SVPDEBUG1( "CSVPSessionBase::TimedOut - MCE established" )

                HandleSessionStateChanged( *iSession );

                SVPDEBUG1( "CSVPSessionBase::TimedOut - hold/resume done" )

                }

            else

                {

                TRAPD( cancelErr, static_cast<CMceOutSession*>( iSession )->CancelL() );

                if ( cancelErr )

                    {

                    // This removes compile warnings; no need for other error 

                    // handling

                    SVPDEBUG2( "CSVPSessionBase::TimedOut - Hold/Resume, Err %i", 

                            cancelErr )

                    }

                }

            SVPDEBUG2( "CSVPSessionBase::TimedOut - Hold/Resume Handled, Err %i",

                    contErr )

            }

        }

    if ( KSVPReferTimerExpired == aTimerId )

        {

        // Refer timeout

        SVPDEBUG1( "CSVPSessionBase::TimedOut Transfer/Refer timer expired" )

        if ( iTransferController )

            {

            // Inform application about the error

            ExecCbErrorOccurred( ECCPTransferFailed );

            // Terminate transfer

            iTransferController->TerminateTransfer();

			}

        }

    if ( KSVPReInviteTimerExpired == aTimerId )

        {

        if ( iHoldController )

            {

            SVPDEBUG1( "CSVPSessionBase::TimedOut - ReInvite timer expired" )

            iHoldController->RetryHoldRequest( iSession );

            }

        }

    if ( KSVPICMPErrorTimerExpired == aTimerId )

        {

        TBool bothStreamsDisabled ( ETrue );

        TRAP_IGNORE( bothStreamsDisabled = IsBothStreamsDisabledL() );

        if ( bothStreamsDisabled )

            {

            SVPDEBUG1( "CSVPSessionBase::TimedOut Error In UL and DL \

            NOT First Time! -> Start Terminating Timer and BYE" )

            // notify CCE about the error & bring session down.

            ExecCbErrorOccurred( ECCPErrorConnectionError );

            ExecCbCallStateChanged( MCCPCallObserver::ECCPStateDisconnecting );

            TRAP_IGNORE( StartTimerL( KSVPTerminatingTime, KSVPRemoteEndDiedExpired ) );

            }

        else

            {

            SVPDEBUG1( "CSVPSessionBase::TimedOut UpLink or DownLink \

            is not Disabled! -> No Terminating Timer needed, all is OK!" )

            }

        SetErrorInULandDLFirstTime( ETrue );        

        }

    if ( KSVPSinkResumeICMPErrorTimerExpired == aTimerId ||

         KSVPSourceResumeICMPErrorTimerExpired == aTimerId )

        {

        if ( iHoldController )

            {

            // ICMP errors in resume disables RTP sink, try to enable it: 

            SVPDEBUG1( "CSVPSessionBase::TimedOut - Resume ICMP error timer expired" )

            TRAPD( refreshErr, HoldController().RefreshHoldStateL() );

            if ( refreshErr )

                {

                // Removes compile warnings; no other error handling

                SVPDEBUG2( "CSVPSessionBase::TimedOut - refreshHold err %d", refreshErr )

                }

            }

        }

    SVPDEBUG1( "CSVPSessionBase::TimedOut Out" )

    }

// ---------------------------------------------------------------------------

// CSVPSessionBase::SessionStateChanged

// ---------------------------------------------------------------------------

//

void CSVPSessionBase::SessionStateChanged( TInt aStatusCode )

    {

    SVPDEBUG2( "CSVPSessionBase::SessionStateChanged  In,  aStatusCode= %d", aStatusCode )

    SVPDEBUG2( "CSVPSessionBase::SessionStateChanged iSession->State()= %d", iSession->State() )

    TInt status = aStatusCode;

    TCCPError err = iSVPUtility.GetCCPError( status, iTone );

    // On error call voip event logger with original status, 3xx are not logged.

    if ( ECCPErrorNone != err && ECCPErrorNotReached != err )

        {

        TRAP_IGNORE( iSVPUtility.LogVoipEventL( aStatusCode,

                iSipProfileId, RemoteParty(), CSeqHeader() ) );

        }

    #ifdef _DEBUG   // UDEB build

    TRAPD( trapErr, SessionStateChangedL( aStatusCode, err, status ) );

    SVPDEBUG2( "CSVPSessionBase::SessionStateChanged trapErr: %d", trapErr )

    #else // UREL build

    TRAP_IGNORE( SessionStateChangedL( aStatusCode, err, status ) );

    #endif // _DEBUG

    SVPDEBUG1( "CSVPSessionBase::SessionStateChanged Out" )

    }

// ---------------------------------------------------------------------------

// CSVPSessionBase::InitializePropertyWatchingL

// ---------------------------------------------------------------------------

//

void CSVPSessionBase::InitializePropertyWatchingL()

    {

    SVPDEBUG1( "CSVPSessionBase::InitializePropertyWatchingL In" )

    // create property watcher for watching mute P&S property changes

    iMutePropertyWatch = CSVPPropertyWatch::NewL(

            *this, KPSUidTelMicrophoneMuteStatus, KTelMicrophoneMuteState );

    // check initial mute value                                  

    TInt value( EPSTelMicMuteOff );

    RProperty::Get( KPSUidTelMicrophoneMuteStatus, 

            KTelMicrophoneMuteState, value );

    // check initial mute status 

    if( EPSTelMicMuteOff == value )

        {

        SVPDEBUG1( "CSVPSessionBase::InitializePropertyWatchingL Initally mute: OFF" )

        }

    else if ( EPSTelMicMuteOn == value )

        {

        SVPDEBUG1( "CSVPSessionBase::InitializePropertyWatchingL Initially Mute: ON" )

        // if mute is initially on, we must mute the audio

        ValueChangedL( KTelMicrophoneMuteState, EPSTelMicMuteOn );

        }

    // create instance of volume obsever

    iVolObserver = CSVPVolumeObserver::NewL( *this );

    SVPDEBUG1( "CSVPSessionBase::InitializePropertyWatchingL Out" )

    }