/*

* 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:   CCP reference plug-in implementation.

*

*/

#include <mccpcall.h>

#include <mccpcallobserver.h>

#include "ccpdefs.h" 

#include <mccpforwardprovider.h>

#include "vccdefinitions.h"

#include "cvccperformer.h"

#include "vcchotrigger.h"

#include "vccsettingsreader.h"

#include "cvcctransferprovider.h"

//state machine

#include "tvccstateinit.h"

#include "tvccstatecalling.h"

#include "tvccstatefailing.h"

#include "tvccstatereleasing.h"

#include "rubydebug.h"

_LIT( KSVPSipPrefix, "sip:" );

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

// 

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

//

CVccPerformer::CVccPerformer(RPointerArray<CConvergedCallProvider>& aProviders,

							 TVccState& aState, CVccHoTrigger& aVccHoTrigger,

							 TBool aCsOriginated ) :

    iProviders(aProviders),

    iCurrentState(&aState),

    iVccHoTrigger( aVccHoTrigger ),

    iCsOriginated( aCsOriginated),

    iTransferProvider( NULL ),

    iRemotePartiesSet( EFalse )

    {

    RUBY_DEBUG_BLOCK( "CVccPerformer::CVccPerformer" );

    }

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

// Default C++ destructor.

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

//

CVccPerformer::~CVccPerformer()

    {

    RUBY_DEBUG0( "CVccPerformer::~CVccPerformer() - ENTER" );

	delete iVccPsp;

	delete iTransferProvider;

    RUBY_DEBUG0( "CVccPerformer::~CVccPerformer() - EXIT" );

    }

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

// Call creating comes here. In MT case observer is null and CCE will call

// SetObserver later on for us

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

//

CVccPerformer* CVccPerformer::NewL(

						RPointerArray<CConvergedCallProvider>& aProviders, 

						TVccState& aState,

						CVccHoTrigger& aVccHoTrigger,

						TBool aCsOriginated)

    {

    RUBY_DEBUG_BLOCKL( "CVccPerformer::NewL" );

    CVccPerformer* self = new( ELeave ) CVccPerformer(aProviders, 

    													aState, 

    													aVccHoTrigger,

    													aCsOriginated);

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// 

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

//

void CVccPerformer::ConstructL()

    {

    RUBY_DEBUG_BLOCKL( "CVccPerformer::ConstructL" );

    iVccPsp = CVccEngPsProperty::NewL();

    }

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

// User has answered the incoming call

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

//

TInt CVccPerformer::Answer()

    {

    RUBY_DEBUG_BLOCK( "CVccPerformer::Answer" );

 	return iCurrentState->Answer(*iPrimaryCall);

    }

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

// User has rejected the incoming call

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

//

TInt CVccPerformer::Reject()

    {

    RUBY_DEBUG_BLOCK( "CVccPerformer::Reject" );

  	return iCurrentState->Reject(*iPrimaryCall);

    }

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

// Queue incoming call

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

//

TInt CVccPerformer::Queue()

    {

    RUBY_DEBUG_BLOCK( "CVccPerformer::Queue" );

 	return iCurrentState->Queue(*iPrimaryCall);

    }

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

// Dial a new call

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

//

TInt CVccPerformer::Dial()

    {

    RUBY_DEBUG_BLOCK( "CVccPerformer::Dial" );

 	return iCurrentState->Dial(*iPrimaryCall);

    }

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

// MT call user ringing now

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

//

TInt CVccPerformer::Ringing()

    {

    RUBY_DEBUG_BLOCK( "CVccPerformer::Ringing" );

	return iCurrentState->Ringing(*iPrimaryCall);

    }

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

// End current call

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

//

TInt CVccPerformer::HangUp()

    {

    RUBY_DEBUG_BLOCK( "CVccPerformer::HangUp" );

    return iCurrentState->HangUp(*this, *iPrimaryCall);

    }

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

// Cancel ongoing request

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

//

TInt CVccPerformer::Cancel()

    {

    RUBY_DEBUG_BLOCK( "CVccPerformer::Cancel" );

  	return iCurrentState->Cancel(*iPrimaryCall);

    }

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

// Hold call

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

//

TInt CVccPerformer::Hold()

    {

    RUBY_DEBUG_BLOCK( "CVccPerformer::Hold" );

    return iCurrentState->Hold(*iPrimaryCall); 

    }

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

// Resume held call

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

//

TInt CVccPerformer::Resume()

    {

    RUBY_DEBUG_BLOCK( "CVccPerformer::Resume" );

 	return iCurrentState->Resume(*iPrimaryCall);

    }

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

// Swap hold/resume states

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

//

TInt CVccPerformer::Swap()

    {

    RUBY_DEBUG_BLOCK( "CVccPerformer::Swap" );

    return iCurrentState->Swap(*iPrimaryCall);

    }

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

// Get call recipient

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

//

const TDesC& CVccPerformer::RemoteParty() const

    {

    RUBY_DEBUG_BLOCK( "CVccPerformer::RemoteParty" );

    return iOrigRemoteParty;

    }

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

// RemotePartyName

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

//

const TDesC& CVccPerformer::RemotePartyName()

    {

    RUBY_DEBUG_BLOCK( "CVccPerformer::RemotePartyName" );

    return iOrigRemotePartyName;

    //return iCurrentState->RemoteParty(*iPrimaryCall);

    }

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

// Get call recipient

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

//

const TDesC& CVccPerformer::DialledParty() const

    {

    RUBY_DEBUG_BLOCK( "CVccPerformer::DialledParty" );

    return iCurrentState->DialledParty(*iPrimaryCall);

    }

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

// Is call forwarded or not

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

//

TBool CVccPerformer::IsCallForwarded() const

    {

    RUBY_DEBUG_BLOCK( "CVccPerformer::IsCallForwarded " );

 	return iCurrentState->IsCallForwarded(*iPrimaryCall);

    }

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

// Is call mobile originated or not

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

//

TBool CVccPerformer::IsMobileOriginated() const

    {

    RUBY_DEBUG_BLOCK( "CVccPerformer::IsMobileOriginated" );

 	return iCurrentState->IsMobileOriginated(*iPrimaryCall);

    }

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

// Get current call state

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

//

MCCPCallObserver::TCCPCallState CVccPerformer::State() const

    {

    RUBY_DEBUG_BLOCK( "CVccPerformer::State " );

 	return iCurrentState->State(*iPrimaryCall);

    }

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

// Get plug-in UID

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

//

TUid CVccPerformer::Uid() const

    {

    RUBY_DEBUG_BLOCK( "CVccPerformer::Uid " );

    return TUid::Uid( KVccCallProviderPlugId );

    }

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

// get call capabilities

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

//

MCCPCallObserver::TCCPCallControlCaps CVccPerformer::Caps() const

    {

    RUBY_DEBUG_BLOCK( "CVccPerformer::CVccPerformer" );

 	return iCurrentState->Caps(*iPrimaryCall);

    }

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

// SecureSpecified()

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

//

TBool CVccPerformer::SecureSpecified() const

    {

    return iCurrentState->SecureSpecified( *iPrimaryCall );

    }

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

// Is call secured

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

//

TBool CVccPerformer::IsSecured() const

    {

    RUBY_DEBUG_BLOCK( "CVccPerformer::IsSecured" );

    return iCurrentState->IsSecured(*iPrimaryCall);

    }

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

// Set parameters

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

//

void CVccPerformer::SetParameters( const CCCPCallParameters& aNewParams )

    {

    RUBY_DEBUG_BLOCK( "CVccPerformer::SetParameters " );

    iCurrentState->SetParameters(aNewParams);

    }

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

// Get parameters

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

//

const CCCPCallParameters& CVccPerformer::Parameters() const

    {

    RUBY_DEBUG_BLOCK( "CVccPerformer::Parameters" );

    return iCurrentState->Parameters(*iPrimaryCall);

    }

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

// Return used tone.

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

//

TCCPTone CVccPerformer::Tone() const

	{

	RUBY_DEBUG_BLOCK( "CVccPerformer::Tone " );

	return iCurrentState->Tone(*iPrimaryCall);

	}

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

// Get forward call enabling methods for the call

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

//

MCCPForwardProvider* CVccPerformer::ForwardProviderL

                                        ( const MCCPForwardObserver& aObserver )

    {

    RUBY_DEBUG_BLOCKL( "CVccPerformer::ForwardProviderL " );

 	return iPrimaryCall->ForwardProviderL(aObserver);

    }

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

// Get transfer call enabling methods for the call

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

//

MCCPTransferProvider* CVccPerformer::TransferProviderL

                                        ( const MCCPTransferObserver& aObserver )

    {

    RUBY_DEBUG_BLOCKL( "CVccPerformer::TransferProviderL " );

	if ( !iTransferProvider )

          {    

          iTransferProvider = CVccTransferProvider::NewL(this);

          iTransferProvider->AddObserverL( aObserver );

          }

    return iTransferProvider;

    }

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

// Add observer.

// the CCE will call that in the MT call case, to put the observer for a call in place

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

//

void CVccPerformer::AddObserverL( const MCCPCallObserver& aObserver )

    {

    RUBY_DEBUG_BLOCKL( "CVccPerformer::AddObserverL " );

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

 	iCurrentState->AddObserverL(*this, *iPrimaryCall);

    }

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

// remove observer.

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

//

TInt CVccPerformer::RemoveObserver(const MCCPCallObserver& aObserver )

    {

    RUBY_DEBUG_BLOCK( "CVccPerformer::RemoveObserver " );

	return iCurrentState->RemoveObserver(aObserver, *iPrimaryCall);

    }

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

// Dial from MCCPCSCall

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

//

TInt CVccPerformer::Dial( const TDesC8& aCallParams )

	{

	RUBY_DEBUG_BLOCK( "CVccPerformer::Dial" );

	return iCurrentState->Dial(aCallParams, 

	                        *static_cast<MCCPCSCall*>(iPrimaryCall));

	}

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

// NoFDNCheck from MCCPCSCall

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

//

void CVccPerformer::NoFDNCheck()

	{

	RUBY_DEBUG_BLOCK( "CVccPerformer::NoFDNCheck " );

	iCurrentState->NoFDNCheck(*static_cast<MCCPCSCall*>(iPrimaryCall));

	}

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

// GetMobileCallInfo from MCCPCSCall

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

//

TInt CVccPerformer::GetMobileCallInfo( TDes8& aCallInfo ) const

	{

	RUBY_DEBUG_BLOCK( "CVccPerformer::GetMobileCallInfo " );

	return iCurrentState->GetMobileCallInfo(aCallInfo,

	                          *static_cast<MCCPCSCall*>(iPrimaryCall));

	}

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

// SwitchAlternatingCall from MCCPCSCall

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

//

TInt CVccPerformer::SwitchAlternatingCall()

	{

	RUBY_DEBUG_BLOCK( "CVccPerformer::SwitchAlternatingCall " );

	return iCurrentState->SwitchAlternatingCall(

	                         *static_cast<MCCPCSCall*>(iPrimaryCall));

	}

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

// GetMobileDataCallCaps from MCCPCSCall

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

//

TInt CVccPerformer::GetMobileDataCallCaps( TDes8& aCaps ) const

	{

	RUBY_DEBUG_BLOCK( "CVccPerformer::GetMobileDataCallCaps " );

	return iCurrentState->GetMobileDataCallCaps(aCaps,

	                          *static_cast<MCCPCSCall*>(iPrimaryCall));

	}

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

// LogDialedNumber from MCCPCSCall

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

//

TInt CVccPerformer::LogDialedNumber() const

	{

	RUBY_DEBUG_BLOCK( "CVccPerformer::LogDialedNumber " );

	return iCurrentState->LogDialedNumber(

	                          *static_cast<MCCPCSCall*>(iPrimaryCall) );

	}

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

// MCCPCallObserver:: ErrorOccurred

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

//

void CVccPerformer::ErrorOccurred(const TCCPError aError, MCCPCall* aCall )

	{

	RUBY_DEBUG_BLOCK( "CVccPerformer::TCCPError ");	

	iCurrentState->ErrorOccurred(*this, aError, aCall );

	}

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

// MCCPCallObserver:: CallStateChanged

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

//	

void CVccPerformer::CallStateChanged( 

                                   const MCCPCallObserver::TCCPCallState aState, 

                                   MCCPCall* aCall  )

	{

	RUBY_DEBUG_BLOCK( "CVccPerformer::CallStateChanged ");

	iCurrentState->CallStateChanged( *this, aState, aCall );		

	}

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

// MCCPCallObserver:: CallStateChangedWithInband

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

//	

void CVccPerformer::CallStateChangedWithInband( 

                                   const MCCPCallObserver::TCCPCallState aState,

                                   MCCPCall* aCall )

	{

	RUBY_DEBUG_BLOCK( "CVccPerformer::CallStateChanged ");

	iCurrentState->CallStateChangedWithInband( *this, aState, aCall );

	}

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

// MCCPCallObserver::CallEventOccurred

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

//	

void CVccPerformer::CallEventOccurred( 

                                   const MCCPCallObserver::TCCPCallEvent aEvent, 

                                   MCCPCall* aCall  )

	{

	RUBY_DEBUG_BLOCK( "CVccPerformer::CallEventOccurred ");

	iCurrentState->CallEventOccurred(*this, aEvent, aCall);

	}

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

// MCCPCallObserver::CallCapsChanged

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

//	

void CVccPerformer::CallCapsChanged(const TUint32 aCapsFlags, MCCPCall* aCall )

	{

	RUBY_DEBUG_BLOCK( "CVccPerformer::CallCapsChanged");

	iCurrentState->CallCapsChanged(*this, aCapsFlags, aCall );

	}

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

//  Get CallObserver()

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

//

MCCPCallObserver* CVccPerformer::CallObserver()

    {

    RUBY_DEBUG_BLOCK( "CVccPerformer::CallObserver " );

  	return iCallObs;

    }

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

//  Creates actual implementation

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

//

MCCPCall* CVccPerformer::CreatePrimaryCallL( 

                                 const CCCPCallParameters& aParameters,

                                 const TDesC& aRecipient,

                                 const MCCPCallObserver& aObserver )

	{

    RUBY_DEBUG_BLOCKL( "CVccPerformer::CreatePrimaryCallL" );

    iPrimaryCall = NULL;

    TInt index = KErrNotFound;

    if (aParameters.CallType() != CCPCall::ECallTypePS )

	    {

	    index = VoipProviderIndex( EFalse );

	    }

    else