/*

* 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:  SVP Emergency Sesssion class. Handles emergency 

*                session methods.        

*

*/

#include <sip.h>

#include <sipprofile.h>

#include <sipprofileregistry.h>

#include <mceaudiostream.h>

#include <mcertpsource.h>

#include <mcertpsink.h>

#include <mcemicsource.h>

#include <mcespeakersink.h>

#include <mcetransactiondatacontainer.h>

#include "crcseprofileentry.h"

#include "crcseprofileregistry.h"

#include "svpemergencysession.h"

#include "svpuriparser.h"

#include "svputility.h"

#include "svpsipconsts.h"

#include "svpconsts.h"

#include "svppositioningprovider.h"

#include "svpemergencyconnection.h"

#include "svpholdcontroller.h"

#include "svpaudioutility.h"

#include "svpdtmfeventgenerator.h"

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

// CSVPEmergencySession::CSVPEmergencySession

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

//

CSVPEmergencySession::CSVPEmergencySession( 

    CSVPUtility& aSVPUtility, 

    CMceManager& aMceManager, 

    TBool aIsLastProfile, 

    TBool aIsDummy )

    : iSVPUtility( aSVPUtility ), 

      iMceManager( aMceManager ), 

      iSessionExpires( KSVPDefaultSessionExpires ), 

      iIsLastProfile( aIsLastProfile ), 

      iIsDummy( aIsDummy ), 

      iIsDialed( EFalse ), 

      iIsLIRequestReady( ETrue )

    {

    }

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

// CSVPEmergencySession::ConstructL

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

//

void CSVPEmergencySession::ConstructL( TUint32 aVoipProfileId, 

                                       const TDesC& aAddress, 

                                       const MCCPCallObserver& aObserver, 

                                       TBool aIsDummy )                                   

    {

    SVPDEBUG2("CSVPEmergencySession::ConstructL() IN, VoIP profile ID: %d", 

        aVoipProfileId)

    iEmergencyObserver = const_cast< MCCPCallObserver* >( &aObserver );

    iVoipProfileId = ( TInt )aVoipProfileId;

    // Start emergency timer, timeout 17 seconds

    StartTimerL( KSVPEmergencyTimeout, KSVPEmergencyExpired );

    if ( aIsDummy )

        {

        SVPDEBUG1("CSVPEmergencySession::ConstructL, dummy session")

        return;

        }

    // Initialize registries

    CRCSEProfileRegistry* reg = CRCSEProfileRegistry::NewLC(); // CS:1

    CSIP* sip = CSIP::NewLC( KSVPUid, *this ); // CS:2

    CSIPProfileRegistry* sipProfileRegistry = CSIPProfileRegistry::NewLC( 

        *sip, *this ); // CS:3

    // Find VoIP profile by its ID

    CRCSEProfileEntry* voipProfile = CRCSEProfileEntry::NewLC();  // CS:4

    reg->FindL( aVoipProfileId, *voipProfile );

    // Set Session Expires value

    iSessionExpires = ( TUint32 )voipProfile->iSIPSessionExpires;

    // There is only one (or zero) SIP profile per VoIP profile.

    // if profileId doesn't exist, report an error ( ECCPErrorGeneral ).

    if ( 0 == voipProfile->iIds.Count() )

        {

        SVPDEBUG1( "CSVPEmergencySession::ConstructL, no SIP profile, return" )

        CleanupStack::PopAndDestroy( 4, reg ); // CS:0

        ErrorOccurred( ECCPErrorGeneral );

        return;

        }

    CSIPProfile* sipProfile = sipProfileRegistry->ProfileL( 

        voipProfile->iIds[0].iProfileId );

    CleanupStack::PushL( sipProfile ); // CS:5

    // Get SIP profile ID

    User::LeaveIfError( 

        sipProfile->GetParameter( KSIPProfileId, iSipProfileId ) );

    // Get user AOR

    const TDesC8* userAor = NULL;

    User::LeaveIfError( sipProfile->GetParameter( KSIPUserAor, userAor ) );

    iUserAor = HBufC8::NewL( userAor->Length() );

    ( iUserAor->Des() ).Copy( *userAor );

    // Parse SIP URI

    HBufC8* recipient = HBufC8::NewLC( aAddress.Length() ); // CS:6

    ( recipient->Des() ).Copy( aAddress );

    CSVPUriParser* uriParser = CSVPUriParser::NewLC(); // CS:7

    iRecipientUri = uriParser->CompleteSipUriL( *recipient, *iUserAor, ETrue );

    CleanupStack::PopAndDestroy( 2, recipient ); // uriparser, recipient CS:5

    // Get registration status

    TBool registered( EFalse );

    sipProfile->GetParameter( KSIPProfileRegistered, registered );

    // Get SNAP ID

    TUint32 snapId( 0 );

    TInt errSnap = sipProfile->GetParameter( KSIPSnapId, snapId );

    // Define IAP ID

    if ( !registered && KErrNone == errSnap )

        {

        SVPDEBUG2("CSVPEmergencySession::ConstructL, snapId: %d", snapId)

        // Define IAP ID from SNAP ID, create WLAN connection

        iEmergencyConnection = CSVPEmergencyConnection::NewL( 

            CActive::EPriorityStandard, *this );

        iEmergencyConnection->ConnectWithSnapIdL( snapId );

        CleanupStack::PopAndDestroy( 5, reg );

        // reg, sip, sipProfileRegistry, voipProfile, sipProfile CS:0

        SVPDEBUG1("CSVPEmergencySession::ConstructL, return")

        return;

        }

    else

        {

        User::LeaveIfError( 

            sipProfile->GetParameter( KSIPAccessPointId, iIapId ) );

        }

    // Create MCE out session

    if ( registered )

        {

        SVPDEBUG1("CSVPEmergencySession::ConstructL, registered")

        iEmergencySession = CMceOutSession::NewL( 

            iMceManager, *sipProfile, *iRecipientUri );

        ConstructAudioStreamsL();

        }

    else

        {

        CreateUnregistedSessionL();

        }

    CleanupStack::PopAndDestroy( 5, reg ); 

    // CS:0 reg, sip, sipProfileRegistry, voipProfile, sipProfile

    // Request for position information

    RequestPosition( iIapId );

    SVPDEBUG1("CSVPEmergencySession::ConstructL() OUT")

    }

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

// CSVPEmergencySession::ConstructWithIapIdL

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

//

void CSVPEmergencySession::ConstructWithIapIdL( 

    TUint32 aIapId, 

    const TDesC& aAddress, 

    const MCCPCallObserver& aObserver, 

    TBool aIsDummy )                                   

    {

    SVPDEBUG2("CSVPEmergencySession::ConstructWithIapIdL() In, IAP ID: %d", 

        aIapId)

    iEmergencyObserver = const_cast< MCCPCallObserver* >( &aObserver );

    iVoipProfileId = KErrNotFound;

    iIapId = aIapId;

    // Copy recipient address

    iAddress = HBufC8::NewL( aAddress.Length() );

    ( iAddress->Des() ).Copy( aAddress );

    // Start emergency timer, timeout 17 seconds

    StartTimerL( KSVPEmergencyTimeout, KSVPEmergencyExpired );

    if ( aIsDummy )

        {

        SVPDEBUG1("CSVPEmergencySession::ConstructWithIapIdL, dummy session")

        return;

        }

    // Request for SIP proxy address

    SVPDEBUG1("CSVPEmergencySession::ConstructWithIapIdL, SIP proxy address")

    iEmergencyConnection = CSVPEmergencyConnection::NewL( 

        CActive::EPriorityStandard, *this );

    iEmergencyConnection->ConnectL( iIapId );

    SVPDEBUG1("CSVPEmergencySession::ConstructWithIapIdL() Out")

    }

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

// CSVPEmergencySession::ContinueConstructWithIapIdL

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

//

void CSVPEmergencySession::RequestSipProxyAddressL()

    {

    if ( NULL == iEmergencyConnection )

        {

        User::Leave( KErrGeneral );

        }

    iEmergencyConnection->RequestSipProxyAddressL( iIapId );

    }

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

// CSVPEmergencySession::ContinueConstructWithIapIdL

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

//

void CSVPEmergencySession::ContinueConstructWithIapIdL( 

    const TDesC16& aSipProxyAddress )

    {

    SVPDEBUG2("CSVPEmergencySession::ContinueConstructWithIapIdL(),\

        SIP proxy address: %S", &aSipProxyAddress)

    if ( 0 == aSipProxyAddress.Length() )

        {

        User::Leave( KErrNotFound );

        }

    // Parse user AOR

    iUserAor = HBufC8::NewL(

        KSVPSipPrefix().Length() + 

        KSVPAnonymous().Length() + 

        KSVPAt().Length() + 

        aSipProxyAddress.Length() );

    TPtr8 userAorPtr = iUserAor->Des();

    userAorPtr.Copy( KSVPSipPrefix );

    userAorPtr.Append( KSVPAnonymous );

    userAorPtr.Append( KSVPAt );

    userAorPtr.Append( aSipProxyAddress );

    // Parse SIP URI

    SVPDEBUG1("CSVPEmergencySession::ContinueConstructWithIapIdL,\

        parse SIP URI")

    CSVPUriParser* uriParser = CSVPUriParser::NewLC(); // CS:1

    iRecipientUri = uriParser->CompleteSipUriL( *iAddress, *iUserAor, ETrue );

    CleanupStack::PopAndDestroy( uriParser ); // CS:0

    // Create MCE session

    CreateUnregistedSessionL();

    // Request for position information

    RequestPosition( iIapId );

    SVPDEBUG1("CSVPEmergencySession::ContinueConstructWithIapIdL() Out")

    }

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

// CSVPEmergencySession::NewL

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

//

CSVPEmergencySession* CSVPEmergencySession::NewL(  

                                        CMceManager& aMceManager, 

                                        TUint32 aVoipProfileId, 

                                        const TDesC& aAddress, 

                                        const MCCPCallObserver& aObserver,

                                        CSVPUtility& aSVPUtility, 

                                        TBool aIsLastProfile, 

                                        TBool aIsDummy )

    {

    CSVPEmergencySession* self = new( ELeave ) CSVPEmergencySession( 

        aSVPUtility, aMceManager, aIsLastProfile, aIsDummy );

    CleanupStack::PushL( self );

    self->ConstructL( aVoipProfileId, aAddress, aObserver, aIsDummy );

    CleanupStack::Pop( self );

    return self;

    }

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

// CSVPEmergencySession::NewL

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

//

CSVPEmergencySession* CSVPEmergencySession::NewL(  

                                        CMceManager& aMceManager, 

                                        const TDesC& aAddress, 

                                        const MCCPCallObserver& aObserver,

                                        CSVPUtility& aSVPUtility, 

                                        TUint32 aIapId, 

                                        TBool aIsLastProfile, 

                                        TBool aIsDummy )

    {

    CSVPEmergencySession* self = new( ELeave ) CSVPEmergencySession( 

        aSVPUtility, aMceManager, aIsLastProfile, aIsDummy );

    CleanupStack::PushL( self );

    self->ConstructWithIapIdL( aIapId, aAddress, aObserver, aIsDummy );

    CleanupStack::Pop( self );

    return self;

    }

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

// CSVPEmergencySession::~CSVPEmergencySession

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

//

CSVPEmergencySession::~CSVPEmergencySession()

    {

    SVPDEBUG1("CSVPEmergencySession::~CSVPEmergencySession() In")

    StopTimers();  

    iTimers.Close();

    delete iEmergencySession;

    delete iFailedEmergencySession;

    delete iUserAor;

    delete iAddress;

    delete iRecipientUri;

    delete iPositionInformation;

    delete iPositioningProvider;

    delete iEmergencyConnection;

    delete iHoldController;

    delete iDTMFEventGenerator;

    delete iDtmfString;

    SVPDEBUG1("CSVPEmergencySession::~CSVPEmergencySession() Out")

    }

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

// CSVPEmergencySession::State

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

//

MCCPCallObserver::TCCPCallState CSVPEmergencySession::State() const

    {

    SVPDEBUG1("CSVPEmergencySession::State()")

    // ccpState can be safely initialized with StatusIdle

    MCCPCallObserver::TCCPCallState ccpState = 

        MCCPCallObserver::ECCPStateIdle;

    switch ( iEmergencySession->State() )

        {

        case CMceSession::EIdle:

            SVPDEBUG1("CSVPEmergencySession::State, MCE EIdle")

            ccpState = MCCPCallObserver::ECCPStateIdle;

            break;

        case CMceSession::EProceeding:

            SVPDEBUG1("CSVPEmergencySession::State, MCE EProceeding")

            ccpState = MCCPCallObserver::ECCPStateConnecting;

            break;

        case CMceSession::EEstablished:

            SVPDEBUG1("CSVPEmergencySession::State, MCE EEstablished")

            ccpState = MCCPCallObserver::ECCPStateConnected;

            break;

        case CMceSession::ECancelling:

            SVPDEBUG1("CSVPEmergencySession::State, MCE ECancelling")

            ccpState = MCCPCallObserver::ECCPStateIdle;  

            break;

        case CMceSession::ETerminating:

            SVPDEBUG1("CSVPEmergencySession::State, MCE ETerminating")

            ccpState = MCCPCallObserver::ECCPStateDisconnecting;

            break;

        case CMceSession::ETerminated:

            SVPDEBUG1("CSVPEmergencySession::State, MCE ETerminated")

            if ( MCCPCallObserver::ECCPStateDisconnecting == iSessionState )

                {

                ccpState = MCCPCallObserver::ECCPStateDisconnecting;

                }

            else

                {

                ccpState = MCCPCallObserver::ECCPStateIdle;     

                }

            break;

        default:

            SVPDEBUG1("CSVPEmergencySession::State, DEFAULT")

            // This block should never be reached.

            break;

        }

    return ccpState;

    }

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

// Traps SessionStateChangedL

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

//

void CSVPEmergencySession::SessionStateChanged( TInt aStatusCode )

    {

    TRAPD( err, SessionStateChangedL( aStatusCode ) )

    if ( err )

        {

        SVPDEBUG2("CSVPEmergencySession::SessionStateChanged, err: %d", err)

        }

    }

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

// Session connection state changed

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

//

void CSVPEmergencySession::SessionConnectionStateChanged(

    CMceSession& aSession, TBool aActive )

    {

    SVPDEBUG2("CSVPEmergencySession::SessionConnectionStateChanged - %d", 

        aActive)

    if ( iEmergencySession == &aSession && aActive )

        {

        ProceedDial();

        }

    }

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

// Stream state changed

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

//

void CSVPEmergencySession::StreamStateChanged( CMceMediaStream& aStream )

    {

    SVPDEBUG1("CSVPEmergencySession::StreamStateChanged()")

    if ( CMceMediaStream::EDisabled == aStream.State() &&

         CMceSession::EEstablished == aStream.Session()->State() )

        {

        // Remote end died

        iEmergencyObserver->CallStateChanged( 

            MCCPCallObserver::ECCPStateDisconnecting, NULL );

        TRAP_IGNORE( StartTimerL( 

            KSVPTerminatingTime, KSVPRemoteEndDiedExpired ) )

        }

    }

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

// Handle incoming request, i.e. hold

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

//

void CSVPEmergencySession::IncomingRequestL( 

    CMceInSession* aUpdatedSession, TMceTransactionDataContainer aContainer )

    {

    SVPDEBUG1("CSVPEmergencySession::IncomingRequest() In")

    if ( !aUpdatedSession )

        {

        User::Leave( KErrArgument );

        }

    // Create hold controller

    if ( NULL == iHoldController )

        {

        iHoldController = CSVPHoldController::NewL( 

            *iEmergencySession,

            aContainer,

            this,

            ETrue );

        }

    iEmergencySession = aUpdatedSession;

    User::LeaveIfError( iHoldController->IncomingRequest( aUpdatedSession ) );

    }

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

// Returns ETrue, if hold controller exists

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

//

TBool CSVPEmergencySession::HasHoldController() const

    {

    if ( iHoldController )

        {

        return ETrue;

        }

    else

        {

        return EFalse;

        }

    }

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

// Returns reference to hold controller

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

//    

CSVPHoldController& CSVPEmergencySession::HoldController() const

    {

    return *iHoldController;

    }

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

// Handles hold session state changes

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

//

void CSVPEmergencySession::HoldSessionStateChangedL( CMceSession& aSession )

    {

    SVPDEBUG1("CSVPEmergencySession::HoldSessionStateChangedL() In")

    if ( NULL == iHoldController )

        {

        User::Leave( KErrNotFound );

        }