/*
* 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:  Representation of SVP MT session              
*
*/

#include <centralrepository.h>
#include <mcesecureoutsession.h>
#include <mceaudiocodec.h>
#include <settingsinternalcrkeys.h>
#include <mcertpsink.h>
#include <mceaudiostream.h>
#include <mceinsession.h>
#include <mcemediasource.h>
#include <mcertpsource.h>

#include "svpmtsession.h"
#include "svpaudioutility.h"
#include "svpsipconsts.h"
#include "svplogger.h"

// ---------------------------------------------------------------------------
// CSVPMtSession::CSVPMtSession
// ---------------------------------------------------------------------------
//
CSVPMtSession::CSVPMtSession( CMceInSession* aMtSession,
                              TMceTransactionDataContainer& aContainer,
                              TUint32 aVoIPProfileId,
                              MSVPSessionObserver& aObserver, 
                              CSVPUtility& aSVPUtility,
                              CSVPRtpObserver& aRtpObserver,
                              TInt aKeepAliveValue,
                              TBool aPreconditions )
    : CSVPSessionBase( aContainer, aObserver, aSVPUtility, aRtpObserver )
    {
    iSession = aMtSession;
    iVoIPProfileId = aVoIPProfileId;
    iKeepAliveValue = aKeepAliveValue;
    iPreconditions = aPreconditions;
    
    CMceSession::TControlPathSecurityLevel securityLevel =
         aMtSession->ControlPathSecurityLevel();

    // Not secure call event is sent according this, in mt case event isn't sent
    iCallEventToBeSent = MCCPCallObserver::ECCPSecureNotSpecified;

    if ( CMceSession::EControlPathSecure == securityLevel &&
         KMceSessionSecure == aMtSession->Type() )
        {
        SVPDEBUG1( "CSVPMtSession::CSVPMtSession Mt secure" )
        iSecured = ETrue;
        }
    else
        {
        SVPDEBUG1( "CSVPMtSession::CSVPMtSession Mt non secure" )
        iSecured = EFalse;
        }
    }

// ---------------------------------------------------------------------------
// CSVPMtSession::NewL
// ---------------------------------------------------------------------------
//
CSVPMtSession* CSVPMtSession::NewL( CMceInSession* aMtSession,
                                    TMceTransactionDataContainer& aContainer,
                                    TUint32 aServiceId,
                                    TUint32 aVoIPProfileId,
                                    MSVPSessionObserver& aObserver,
                                    CSVPUtility& aSVPUtility,
                                    CSVPRtpObserver& aRtpObserver,
                                    TInt aKeepAliveValue,
                                    TBool aPreconditions )
    {
    CSVPMtSession* self = new ( ELeave ) CSVPMtSession( aMtSession,
                                                     aContainer, 
                                                     aVoIPProfileId,
                                                     aObserver,
                                                     aSVPUtility,
                                                     aRtpObserver,
                                                     aKeepAliveValue,
                                                     aPreconditions );
    CleanupStack::PushL( self );
    self->ConstructL( aServiceId );
    CleanupStack::Pop( self );
    return self;
    }

// ---------------------------------------------------------------------------
// CSVPMtSession::~CSVPMtSession
// ---------------------------------------------------------------------------
//
CSVPMtSession::~CSVPMtSession()
    {
    SVPDEBUG1( "CSVPMtSession::~CSVPMtSession" )
    }

// ---------------------------------------------------------------------------
// CSVPMtSession::ConstructL
// ---------------------------------------------------------------------------
//
void CSVPMtSession::ConstructL( TUint32 aServiceId )
    {
    SVPDEBUG1( "CSVPMtSession::ConstructL In" )
    
    iCallParameters = CCCPCallParameters::NewL();
    iCallParameters->SetServiceId( aServiceId );
    iCallParameters->SetCallType( CCPCall::ECallTypePS );
    
    // modify QoS preconditions
    if ( iPreconditions )
        {
        SVPDEBUG1( "CSVPMtSession::ConstructL preconditions supported" )
        iSession->SetModifierL( KMcePreconditions, KMcePreconditionsSupported );
        }
    else
        {
        SVPDEBUG1( "CSVPMtSession::ConstructL preconditions NOT supported" )
        iSession->SetModifierL( KMcePreconditions, KMcePreconditionsNotUsed );
        }
    
    // modify Old way hold on
    iSession->SetModifierL( KMceMediaDirection, KMceMediaDirectionWithAddress );
    
    InitializePropertyWatchingL();
    
    SVPDEBUG1( "CSVPMtSession::ConstructL Out" )
    }


// from MCCPCall
// ---------------------------------------------------------------------------
// CSVPMtSession::Answer
// ---------------------------------------------------------------------------
//      
TInt CSVPMtSession::Answer()
    {
    SVPDEBUG1( "CSVPMtSession::Answer In" )
    
    // stop expires timer
    StopTimers();
    
    // answer to session
    TRAPD( err, DoAnswerL() );
    
    if ( KErrNone != err )
        {
        SVPDEBUG2( "CSVPMtSession::Answer Out return(err)=%d", err )
        return err;
        }
    else
        {
        ExecCbCallStateChanged( MCCPCallObserver::ECCPStateAnswering );
        SVPDEBUG2( "CSVPMtSession::Answer Out return=%d", err )
        return err;
        }
    }

// ---------------------------------------------------------------------------
// CSVPMtSession::DoAnswerL
// ---------------------------------------------------------------------------
//      
void CSVPMtSession::DoAnswerL()
    {
    SVPDEBUG1( "CSVPMtSession::DoAnswerL In" )
    
    static_cast<CMceInSession*>( iSession )->AcceptL();
    HandleMtStreamsL( iSession->Streams() );
    
    SVPDEBUG1( "CSVPMtSession::DoAnswerL Out" )
    }

// ---------------------------------------------------------------------------
// CSVPMtSession::HandleMtStreamsL
// ---------------------------------------------------------------------------
// 
void CSVPMtSession::HandleMtStreamsL(
    const RPointerArray<CMceMediaStream>& aStreams )
    {
    SVPDEBUG1( "CSVPMtSession::HandleMtStreamsL In" )
    
    // go through streams and enable rtp source and speaker sink if found
    for ( TInt i = 0; i < aStreams.Count(); i++ )
        {
        SVPDEBUG1( "CSVPMtSession::HandleMtStreamsL for-loop" )
        
        CMceMediaStream* stream1 = aStreams[ i ];
        CMceMediaStream& boundStream = stream1->BoundStreamL();// fetch bound stream
        
        // enable RTP source
        if ( stream1->Source() && stream1->Source()->Type() == KMceRTPSource )
            {
            SVPDEBUG1( "CSVPMtSession::HandleMtStreamsL RTPSource found" )
        	stream1->Source()->EnableL();
        	SVPDEBUG1( "CSVPMtSession::HandleMtStreamsL RTPSource ENABLED" )
            }
        
        // enable speaker sink    
        SVPAudioUtility::EnableSpeakerSinkL( stream1->Sinks() );
        
        // enable mic source
        if ( stream1->Source() )
            {
            SVPAudioUtility::EnableMicSourceL( *stream1->Source() );
        	}
        
        // enable mic source from bound stream, if found
        if ( boundStream.Source() )
            {
            SVPAudioUtility::EnableMicSourceL( *boundStream.Source() );
            }
        }
    
    SVPDEBUG1( "CSVPMtSession::HandleMtStreamsL Out" )
    }

// ---------------------------------------------------------------------------
// CSVPMtSession::IsCallForwarded
// ---------------------------------------------------------------------------
//     
TBool CSVPMtSession::IsCallForwarded() const
    {
    return EFalse;  
    }
    
// ---------------------------------------------------------------------------
// CSVPMtSession::Release
// ---------------------------------------------------------------------------
//      
TInt CSVPMtSession::Release()
    {
    SVPDEBUG1( "CSVPMtSession::Release" )
    delete this;
    return KErrNone; 
    }
            
// ---------------------------------------------------------------------------
// CSVPMtSession::Reject
// ---------------------------------------------------------------------------
// 
TInt CSVPMtSession::Reject()
    {
    SVPDEBUG1( "CSVPMtSession::Reject In" )
    
    TRAPD( err, static_cast<CMceInSession*>(iSession )->RejectL(
            KSVPBusyHereReason, KSVPBusyHereVal ) );
    
    if ( !err )
        {
        ExecCbCallStateChanged( MCCPCallObserver::ECCPStateIdle );
        }
    
    SVPDEBUG2( "CSVPMtSession::Reject Out return=%d", err )
    return err;
    }

// ---------------------------------------------------------------------------
// CSVPMtSession::Queue
// ---------------------------------------------------------------------------
// 
TInt CSVPMtSession::Queue()
    {
    SVPDEBUG1( "CSVPMtSession::Queue In" )
    
    // Get PS waiting setting 
    TInt error( KErrNone );
    TInt psWaiting( EFalse );
    CRepository* repository = NULL;
    
    TRAP( error, repository = CRepository::NewL( KCRUidRichCallSettings ) );
    
    if ( KErrNone == error )
        {
        error = repository->Get( KRCSPSCallWaiting, psWaiting );
        delete repository;
        repository = NULL;
        
        if ( psWaiting )
            {
            // send 180 ringing
            Ringing();
            SVPDEBUG1( "CSVPMtSession::Queue Sending 180 Ringing" )
            
            // send 182 queued
            SVPDEBUG1( "CSVPMtSession::Queue() Sending 182 Queued" )
            TRAPD( err, static_cast<CMceInSession*> ( iSession )->RespondL(
                    KSVPQueuedReason, KSVPQueuedVal ) );
            
            if ( err )
                {
                SVPDEBUG2( "CSVPMtSession::Queue Out return=%d", err )
                return err;
                }
            }
        else
            {
            // ps waiting off, return error
            SVPDEBUG1( "CSVPMtSession::Queue Out return=KErrNotReady" )
            return KErrNotReady;
            }
        }
    
    SVPDEBUG2( "CSVPMtSession::Queue Out return=%d", error )
    return error;
    }

// ---------------------------------------------------------------------------
// CSVPMtSession::Ringing
// ---------------------------------------------------------------------------
// 
TInt CSVPMtSession::Ringing()
    {
    SVPDEBUG1( "CSVPMtSession::Ringing In" )
    
    TRAPD( err, static_cast<CMceInSession*>( iSession )->RingL() );
    
    SVPDEBUG2( "CSVPMtSession::Ringing Out return=%d", err )
    return err;
    }

// ---------------------------------------------------------------------------
// CSVPMtSession::Hold
// ---------------------------------------------------------------------------
//
TInt CSVPMtSession::Hold()
    {
    SVPDEBUG1( "CSVPMtSession::Hold In" )
    
    TBool sessionUpdateOngoing = ETrue;
    TRAP_IGNORE( SetRtpKeepAliveL( iSession, sessionUpdateOngoing ) );
    
    TInt status = CSVPSessionBase::Hold();
    
    SVPDEBUG2( "CSVPMtSession::Hold Out return=%d", status )
    return status;
    }

// ---------------------------------------------------------------------------
// CSVPMtSession::Resume
// ---------------------------------------------------------------------------
//
TInt CSVPMtSession::Resume()
    {
    SVPDEBUG1( "CSVPMtSession::Resume" )
    return CSVPSessionBase::Resume();
    }
 
// ---------------------------------------------------------------------------
// CSVPMtSession::IsMobileOriginated
// ---------------------------------------------------------------------------
//
TBool CSVPMtSession::IsMobileOriginated() const
    {
    SVPDEBUG1( "CSVPMtSession::IsMobileOriginated = EFalse" )
    return EFalse;
    }

// ---------------------------------------------------------------------------
// CSVPMtSession::SetRtpKeepAliveL
// ---------------------------------------------------------------------------
//
void CSVPMtSession::SetRtpKeepAliveL( CMceSession* aSession,
        TBool aSessionUpdateOngoing )
    {
    SVPDEBUG1( "CSVPMtSession::SetRtpKeepAliveL In" )
    
    __ASSERT_ALWAYS( aSession, User::Leave( KErrArgument ) );
    UpdateKeepAliveL( *aSession, aSessionUpdateOngoing );
    
    SVPDEBUG1( "CSVPMtSession::SetRtpKeepAliveL Out" )
    }