/*

* Copyright (c) 2006-2009 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:  Handles all common logic for SVP and handles sessions.        

*

*/

#include <mcevideostream.h>

#include <mceaudiocodec.h>

#include <mcemediasink.h>

#include <mcemediasource.h>

#include <mceevent.h>

#include <mcesession.h>

#include <mceinrefer.h>

#include <mcesecuresession.h>

#include <mcertpsource.h>

#include <mccpdtmfobserver.h>

#include <sipstrings.h>

#include <sipstrconsts.h>

#include <crcseprofileentry.h>

#include <crcseprofileregistry.h>

#include <wlantrafficstreamparameters.h> // CWlanMgmtClient

#include <ccpdefs.h>

#include <featdiscovery.h>

#include "svpcontroller.h"

#include "svpmosession.h"

#include "svpmtsession.h"

#include "svplogger.h"

#include "svptimer.h"

#include "svputility.h"

#include "svpholdcontext.h"

#include "svpholdcontroller.h"

#include "svpcleanupresetanddestroy.h"

#include "svpaudioutility.h"

#include "svpsipconsts.h"

#include "svpemergencyiapprovider.h"

#include "svprtpobserver.h"

#include "svpsettings.h"

#include "svptransferstatecontext.h"

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

// CSVPController::CSVPController

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

//

CSVPController::CSVPController() : iSessionUpdateOngoing( EFalse )

    {

    }

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

// CSVPController::ConstructL

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

//

void CSVPController::ConstructL()

    {

    SVPDEBUG1( "CSVPController::ConstructL In" )

    iIncomingReferCallIndex = KErrNotFound;

    iHoldCallIndex = KErrNotFound;

    iSuppServices = CSVPSupplementaryServices::NewL();

    iSVPUtility = CSVPUtility::NewL();

    iRtpObserver = CSVPRtpObserver::NewL();

    TBool wlanSupported = CFeatureDiscovery::IsFeatureSupportedL( KFeatureIdProtocolWlan );

#ifndef __WINS__

    if ( wlanSupported )

        {

        iWlanMgmt = CWlanMgmtClient::NewL();

        }

#endif // __WINS__

    SVPDEBUG1( "CSVPController::ConstructL Out" )

    }

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

// CSVPController::NewL

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

//

CSVPController* CSVPController::NewL()

    {

    CSVPController* self = new ( ELeave ) CSVPController();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CSVPController::~CSVPController

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

//

CSVPController::~CSVPController()

    {

    SVPDEBUG1( "CSVPController::~CSVPController In" )

#ifndef __WINS__

    delete iWlanMgmt;

#endif // __WINS__

    delete iSVPUtility;

    // clean array that contains SVP sessions.

    iSessionArray.ResetAndDestroy();

    iSessionArray.Close();

    // SVP emergency session

    delete iEmergencySession;

    iEmergencyProfileIds.Close();

    iEmergencyIapIds.Close();

    delete iSuppServices;

    delete iMceManager;

    delete iRtpObserver;

    delete iDtmfString;

    SVPDEBUG1( "CSVPController::~CSVPController Out" )

    }

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

// CSVPController::InitializeL 

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

//

void CSVPController::InitializeL( const TUint32 aServiceId,

		  					      const MCCPObserver& aMonitor, 

		                          const MCCPSsObserver& aSsObserver )

    {

    SVPDEBUG2( "CSVPController::InitializeL serviceId = %d", aServiceId )

    SVPDEBUG2( "CSVPController::InitializeL iCCPMonitor: 0x%x", iCCPMonitor )

    //Find callprovider plugin uid that should be used when registering to MCE

    TInt ccpUid = SvpSettings::IntPropertyL( aServiceId, 

										EPropertyCallProviderPluginId );

    SVPDEBUG2( "CSVPController::InitializeL callproviderpluginuid=%d", ccpUid )

    // See CConvergedCallProvider API documentation. If already called,

    // leave with KErrAlreadyExists.

    __ASSERT_ALWAYS( !iCCPMonitor, User::Leave( KErrAlreadyExists ) );

    __ASSERT_ALWAYS( !iCCPSsObserver, User::Leave( KErrAlreadyExists ) );

    __ASSERT_ALWAYS( iSVPUtility, User::Leave( KErrNotReady ) );

    __ASSERT_ALWAYS( iRtpObserver, User::Leave( KErrNotReady ) );

    // save CCP monitor 

    iCCPMonitor = const_cast< MCCPObserver* >( &aMonitor );

    // save CCP Supplementary Services observer

    iCCPSsObserver = const_cast< MCCPSsObserver* >( &aSsObserver );

    // get terminal type and wlan mac address, needed for user agent header

    iSVPUtility->GetTerminalTypeL( iTerminalType );

    iSVPUtility->GetWlanMACAddressL( iWlanMacAddress );

    TUid uid = { ccpUid };

    // create Mce Manager, establishes connection to Mce server

    iMceManager = CMceManager::NewL( uid, &iContainer );

    // set observers for asynchronous events

    iMceManager->SetSessionObserver( this );

    iMceManager->SetInSessionObserver( this );

    iMceManager->SetInReferObserver( this );

    iMceManager->SetReferObserver( this );

    iMceManager->SetMediaObserver( this );

    iMceManager->SetEventObserver( this );

    iMceManager->SetDtmfObserver( this );

    iMceManager->SetRtpObserver( iRtpObserver );

    iTrafficStreamCreated = EFalse;

    SVPDEBUG1( "CSVPController::InitializeL Out" )

    } 

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

// CSVPController::InitializeL 

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

//

void CSVPController::InitializeL( const MCCPObserver& aMonitor,

                                  const MCCPSsObserver& aSsObserver )

    {

    SVPDEBUG2( "CSVPController::InitializeL iCCPMonitor: 0x%x", iCCPMonitor )

    SVPDEBUG2( "CSVPController::InitializeL iCCPSsObserver: 0x%x", iCCPSsObserver )

    // See CConvergedCallProvider API documentation. If already called,

    // leave with KErrAlreadyExists.

    __ASSERT_ALWAYS( !iCCPMonitor, User::Leave( KErrAlreadyExists ) );

    __ASSERT_ALWAYS( !iCCPSsObserver, User::Leave( KErrAlreadyExists ) );

    __ASSERT_ALWAYS( iSVPUtility, User::Leave( KErrNotReady ) );

    __ASSERT_ALWAYS( iRtpObserver, User::Leave( KErrNotReady ) );

    // save CCP monitor 

    iCCPMonitor = const_cast< MCCPObserver* >( &aMonitor );

    // save CCP Supplementary Services observer

    iCCPSsObserver = const_cast< MCCPSsObserver* >( &aSsObserver );

    // get terminal type and wlan mac address, needed for user agent header

    iSVPUtility->GetTerminalTypeL( iTerminalType );

    iSVPUtility->GetWlanMACAddressL( iWlanMacAddress );

    // create Mce Manager, establishes connection to Mce server

    iMceManager = CMceManager::NewL( KSVPImplementationUid, &iContainer );

    // set observers for asynchronous events

    iMceManager->SetSessionObserver( this );

    iMceManager->SetInSessionObserver( this );

    iMceManager->SetInReferObserver( this );

    iMceManager->SetReferObserver( this );

    iMceManager->SetMediaObserver( this );

    iMceManager->SetEventObserver( this );

    iMceManager->SetDtmfObserver( this );

    iMceManager->SetRtpObserver( iRtpObserver );

    iTrafficStreamCreated = EFalse;

    SVPDEBUG1( "CSVPController::InitializeL Out" )

    }

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

// CSVPController::NewCallL

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

// 

MCCPCall* CSVPController::NewCallL( 

                            const CCCPCallParameters& aParameters,

                            const TDesC& aRecipient,

                            const MCCPCallObserver& aObserver )

    {

    SVPDEBUG1( "CSVPController::NewCallL In" )

    __ASSERT_ALWAYS( &aParameters, User::Leave( KErrArgument ) );

    __ASSERT_ALWAYS( &aRecipient, User::Leave( KErrArgument ) );

    __ASSERT_ALWAYS( &aObserver, User::Leave( KErrArgument ) );

#ifndef __WINS__

    // Preliminary Call Admission Control implementation, run only if no stream yet open

    if ( !iTrafficStreamCreated )

        {

        SVPDEBUG1( "CSVPController::NewCallL - Creating WLAN traffic stream.." )

        TRequestStatus requestStatus;

        TUint streamId = 0;

        TWlanTrafficStreamParameters streamParams( KSVPWlanTrafficStreamParamUserPriority );

        TWlanTrafficStreamStatus streamStatus = EWlanTrafficStreamStatusActive;

        // Disabling WLAN traffic stream automation and get stream status

        iWlanMgmt->CreateTrafficStream( requestStatus, streamParams, streamId, streamStatus );

        User::WaitForRequest( requestStatus );

        // Save traffic stream ID, needed for stream deletion

        iTrafficStreamId = streamId;

        if ( EWlanTrafficStreamStatusInactiveNoBandwidth == streamStatus )

            {

            SVPDEBUG1( "CSVPController::NewCallL - No bandwidth in traffic stream, leaving with ECCPErrorNetworkBusy" )        

            // Enabling WLAN traffic stream automation back by deleting used stream

            iWlanMgmt->DeleteTrafficStream( requestStatus, iTrafficStreamId );

            User::WaitForRequest( requestStatus );

            TCCPError err = ECCPErrorNetworkBusy;

            User::Leave( err );

            }

        SVPDEBUG1( "CSVPController::NewCallL - WLAN traffic stream created, continuing with NewCallL" )

        iTrafficStreamCreated = ETrue;

        }

    else

        {

        SVPDEBUG1( "CSVPController::NewCallL - WLAN traffic stream already created, continuing with NewCallL" )

        ;

        }

#endif // __WINS__

    SVPDEBUG2( "CSVPController::NewCallL aRecipient length = %d", aRecipient.Length() )

    SVPDEBUG2( "CSVPController::NewCallL aRecipient = %S", &aRecipient )

    SVPDEBUG2( "CSVPController::NewCallL Serviceid = %d", aParameters.ServiceId() )

    // Prepare and remove possible DTMF suffix

    HBufC* parsedRecipient = NULL;

    parsedRecipient = ParseRecipientDtmfSuffixL( aRecipient );

    // "convert" recpient to 8-bit format

    HBufC8* recipient = HBufC8::NewLC( parsedRecipient->Length() ); // CS:1

    TPtr8 temp = recipient->Des();

    temp.Copy( *parsedRecipient );

    // Pointer to parsedRecipient no longer needed

    delete parsedRecipient;

    parsedRecipient = NULL;

    // fetch SIP profile ID from VoIP profiles

    RPointerArray< CRCSEProfileEntry > entryArray;

    CleanupResetAndDestroy<

        RPointerArray<CRCSEProfileEntry> >::PushL( entryArray ); //CS:2

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

    // take service id to local variable

    TUint32 serviceId = aParameters.ServiceId();

    // Get VoIP profile by service id

    reg->FindByServiceIdL( serviceId, entryArray );

    __ASSERT_ALWAYS( entryArray.Count(), User::Leave( KErrArgument ) );

    // Take first entry from array

    CRCSEProfileEntry* entry = entryArray[0];

    // create new session

    MCCPCall* moSessionTemp = CreateNewSessionL( *recipient, 

                                                 *entry, 

                                                 aParameters,

                                                 aObserver );

    CleanupStack::PopAndDestroy( 2, &entryArray ); // CS:1

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

    SVPDEBUG1( "CSVPController::NewCallL Out" )

    return moSessionTemp;

    }

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

// CSVPController::CreateNewSessionL

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

//

MCCPCall* CSVPController::CreateNewSessionL( 

    TDesC8& aRecipient, 

    CRCSEProfileEntry& aVoipProfile, 

    const CCCPCallParameters& aParameters,

    const MCCPCallObserver& aObserver )

    {

    SVPDEBUG1( "CSVPController::CreateNewSessionL In" )

    // array for provisioned data

    CDesC8ArrayFlat* userAgentHeaders = new( ELeave ) CDesC8ArrayFlat( 4 );

    CleanupStack::PushL( userAgentHeaders ); // CS:1

    // variable for storing security status

    TUint32 securityStatus( 0 );

    // set provisioning data

    SVPDEBUG1( "CSVPController::CreateNewSessionL Set provisioning data..." )

    iSVPUtility->SetProvisioningDataL( aVoipProfile, 

                                       *userAgentHeaders,

                                       securityStatus,

                                       iTerminalType,

                                       iWlanMacAddress  );

    SVPDEBUG2( "CSVPController::CreateNewSessionL Security status: %d", securityStatus )

    SVPDEBUG2( "CSVPController::CreateNewSessionL UAHeaders count: %d", userAgentHeaders->Count() )

    // Creates a SVP Mo session 

    CSVPMoSession* moSessionTemp = CSVPMoSession::NewL( *iMceManager,

                                                        aRecipient,

                                                        aVoipProfile, 

                                                        aParameters,

                                                        iContainer,

                                                        *this,

                                                        *iSVPUtility,

                                                        *iRtpObserver,

                                                        securityStatus,

                                                        userAgentHeaders );

    CleanupStack::Pop( userAgentHeaders ); // CS:0, to member data

    CleanupStack::PushL( moSessionTemp ); // CS:1

    FinalizeSessionCreationL( moSessionTemp );

    // set CCP session observer to SVP session

    moSessionTemp->AddObserverL( aObserver );

    // set CCP supplementary services events observer to SVP session

    moSessionTemp->SetSsObserver( *iCCPSsObserver );

    CleanupStack::Pop( moSessionTemp ); // CS:0

    // session pointer is passed to CCP

    SVPDEBUG1( "CSVPController::CreateNewSessionL Out" )

    return moSessionTemp;

    }

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

// Releases call

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

// 

TInt CSVPController::ReleaseCall( MCCPCall& aCall )

    {

    SVPDEBUG1( "CSVPController::ReleaseCall In" )

    TInt response = KErrNotFound;

    // To ensure correct value

    iIncomingReferCallIndex = KErrNotFound;

    iSessionUpdateOngoing = EFalse;

    for ( TInt i = 0; i < iSessionArray.Count(); i++ )

        {

        if ( iSessionArray[i] == &aCall )

            {

            if ( iDtmfStringSending )

                {

                SVPDEBUG1( "CSVPController::ReleaseCall - Abort DTMF Sending" )

                // send abort event

                iSessionArray[i]->DtmfObserver().HandleDTMFEvent(

                       MCCPDTMFObserver::ECCPDtmfSequenceAbort,

                       KErrNone,

                       iDtmfStringLex.Peek() );

                SVPDEBUG1( "CSVPController::ReleaseCall - Complete DTMF" )

                // send sequence completed event

                iSessionArray[i]->DtmfObserver().HandleDTMFEvent(

                    MCCPDTMFObserver::ECCPDtmfStringSendingCompleted,

                    KErrNone,

                    iDtmfStringLex.Peek() );

                // sequence complete, clear flags

                iDtmfStringSending = EFalse;

                iFirstDtmfSent = EFalse;

                delete iDtmfString;

                iDtmfString = NULL;

                }

            iSessionArray[i]->Release();

            response = KErrNone;

            }

        }

#ifndef __WINS__

    // Preliminary Call Admission Control implementation, delete only if created in NewCallL 

    if ( iTrafficStreamCreated )

        {

        SVPDEBUG1( "CSVPController::ReleaseCall - Deleting WLAN traffic stream" )

        TRequestStatus requestStatus;

        // Enabling WLAN traffic stream automation back by deleting used stream

        iWlanMgmt->DeleteTrafficStream( requestStatus, iTrafficStreamId );

        User::WaitForRequest( requestStatus );

        iTrafficStreamCreated = EFalse;

        SVPDEBUG1( "CSVPController::ReleaseCall - WLAN traffic stream deleted" )

        }

    else

        {

        SVPDEBUG1( "CSVPController::ReleaseCall - No WLAN traffic stream to delete" )

        ;

        }

#endif // __WINS__

    SVPDEBUG1( "CSVPController::ReleaseCall Out" )

    return response;

    }

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

// Releases emergency call

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

// 

TInt CSVPController::ReleaseEmergencyCall( MCCPEmergencyCall& /*aCall*/ )

    {

    SVPDEBUG1( "CSVPController::ReleaseEmergencyCall In" )

    // To ensure correct value next time

    iIncomingReferCallIndex = KErrNotFound;

    iSessionUpdateOngoing = EFalse;

    delete iEmergencySession;

    iEmergencySession = NULL;

    SVPDEBUG1( "CSVPController::ReleaseEmergencyCall Out" )

    return KErrNone;

    }

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

// Releases conference call

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

// 

TInt CSVPController::ReleaseConferenceCall( MCCPConferenceCall& /*aCall*/ )

    {

    SVPDEBUG1( "CSVPController::ReleaseConferenceCall In" )

    SVPDEBUG1( "CSVPController::ReleaseConferenceCall Out" )

    return KErrNotSupported;

    }

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

// CSVPController::RemoveFromArray

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

// 

void CSVPController::RemoveFromArray( CSVPSessionBase& aSession )

    {

    SVPDEBUG1( "CSVPController::RemoveFromArray In" )

    // When Sessions destructor is called object be removed from array

    // manually after when data has been deleted.

    SVPDEBUG2( "CSVPController::RemoveFromArray aSession: 0x%x", &aSession )

    TInt index = FindSVPSession( aSession.Session() );  

    if ( KErrNotFound != index )

        {

        SVPDEBUG1( "CSVPController::RemoveFromArray Session found - removing" )

        iSessionArray.Remove( index );

        iSessionArray.Compress();

        }

    // Try also to remove it from RTCP observer. Ingore the return code, yet

    // again this is "just in case" thing.

    iRtpObserver->RemoveSessionFromObserving( &aSession );

    SVPDEBUG1( "CSVPController::RemoveFromArray Out" )

    }

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

// CSVPController::FindSVPSession

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

//

TInt CSVPController::FindSVPSession( const CMceSession& aSession ) const

    {