/*
* Copyright (c) 2007-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:   Implementation for the VCC Init state
*
*/

#include "tvccstateinit.h"
#include "cvccperformer.h"
#include "vccsettingsreader.h"
#include "rubydebug.h"

// -----------------------------------------------------------------------------
// c'tor
// -----------------------------------------------------------------------------
//

TVccStateInit::TVccStateInit()
	{
	RUBY_DEBUG_BLOCK( "TVccStateInit::TVccStateInit" );	
	} 

// -----------------------------------------------------------------------------
// Name
// -----------------------------------------------------------------------------
//	
TUint TVccStateInit::Name() const
	{
	RUBY_DEBUG_BLOCK( "TVccStateInit::Name" );
	return KVccStateInit;
	}

// -----------------------------------------------------------------------------
// LinkState
// -----------------------------------------------------------------------------
//
void TVccStateInit::LinkState(TVccState& aCalling)
	{
	RUBY_DEBUG_BLOCK( "TVccStateInit::LinkState" );
	iCalling = &aCalling;
	}
	
// -----------------------------------------------------------------------------
// Swap()
// -----------------------------------------------------------------------------
//
TInt TVccStateInit::Swap(MCCPCall& aCall)
	{
	RUBY_DEBUG_BLOCK( "TVccStateInit::Swap()" );
	return aCall.Swap();		
	}

// -----------------------------------------------------------------------------
// From MCCPCallObserver
// -----------------------------------------------------------------------------
//
void TVccStateInit::ErrorOccurred( CVccPerformer& aContext, 
                                   const TCCPError aError,
                                   MCCPCall* /*aCall*/ )
	{
	RUBY_DEBUG_BLOCK( "TVccStateInit::ErrorOccurred" );
	__ASSERT_DEBUG(aContext.CallObserver()!=NULL, User::Invariant());
	aContext.CallObserver()->ErrorOccurred( aError, 
	                                        aContext.PrimaryCall() );
	}

// -----------------------------------------------------------------------------
// From MCCPCallObserver 
// -----------------------------------------------------------------------------
//
void TVccStateInit::CallStateChanged( CVccPerformer& aContext, 
                                  const MCCPCallObserver::TCCPCallState aState,
                                  MCCPCall* /*aCall*/ )
	{
	RUBY_DEBUG_BLOCK( "TVccStateInit::CallStateChanged" );
	__ASSERT_DEBUG(aContext.CallObserver()!=NULL, User::Invariant());
	//start trigger if call is connected, stop if not.
	if( aState == MCCPCallObserver::ECCPStateConnected )
		{
		aContext.SetRemoteParties();
		aContext.ActivateTrigger( ETrue );
		
		}
	else
		{
		aContext.ActivateTrigger( EFalse );
		}
	aContext.CallObserver()->CallStateChanged( aState, 
	                                           aContext.PrimaryCall());
	}

// -----------------------------------------------------------------------------
// From MCCPCallObserver
// -----------------------------------------------------------------------------
//
void TVccStateInit::CallStateChangedWithInband( CVccPerformer& aContext, 
                                  const MCCPCallObserver::TCCPCallState aState,
                                  MCCPCall* /*aCall*/ )
	{
	RUBY_DEBUG_BLOCK( "TVccStateInit::CallStateChangedWithInband" );
	__ASSERT_DEBUG(aContext.CallObserver()!=NULL, User::Invariant());
	aContext.CallObserver()->CallStateChangedWithInband( aState, 
	                                                aContext.PrimaryCall());
		
	}

// -----------------------------------------------------------------------------
// From MCCPCallObserver
// -----------------------------------------------------------------------------
//
void TVccStateInit::CallEventOccurred( CVccPerformer& aContext, 
                                  const MCCPCallObserver::TCCPCallEvent aEvent,
                                  MCCPCall* aCall )
	{
	RUBY_DEBUG_BLOCK( "TVccStateInit::CallEventOccurred" );
	RUBY_DEBUG1( "TVccStateInit::CallEventOccurred, event: %d", aEvent );
	__ASSERT_DEBUG(aContext.CallObserver()!=NULL, User::Invariant());
	
	   if(  aContext.PrimaryCall() == aCall )
	        {
             //if remote end holds the call HO is not allowed at this end either
	        if( aEvent == MCCPCallObserver::ECCPRemoteHold )
	            {
	            //Trigger is informed that automatic HO is not allowed. 
	            aContext.ActivateTrigger( EFalse );
	            //for manual HO PS key needs to be updated
	            aContext.AllowHo( EFalse ); 
	            }
	        
	        else if( aEvent == MCCPCallObserver::ECCPRemoteResume )
	            {
	            //HO is allowed again
	            aContext.ActivateTrigger( ETrue );
	            //for manual HO PS key needs to be updated
	            aContext.AllowHo( ETrue );
	            }
	        else if( aEvent == MCCPCallObserver::ECCPNotifyRemotePartyInfoChange )
	            {
	            aContext.SetRemoteParties();
	            }
	
	    RUBY_DEBUG0("primary call event, forward it");
	    aContext.CallObserver()->CallEventOccurred( aEvent, 
	                                                 aContext.PrimaryCall());
	    }

	}
// -----------------------------------------------------------------------------
// From MCCPCallObserver
// -----------------------------------------------------------------------------
//
void TVccStateInit::CallCapsChanged( CVccPerformer& aContext, 
                                     const TUint32 aCapsFlags )
	{
	RUBY_DEBUG_BLOCK( "TVccStateInit::CallCapsChanged" );
	__ASSERT_DEBUG(aContext.CallObserver()!=NULL, User::Invariant());
	aContext.CallObserver()->CallCapsChanged( aCapsFlags,
	                                          aContext.PrimaryCall() );	
	}
	 
// -----------------------------------------------------------------------------
// 	SwitchL()
// -----------------------------------------------------------------------------
//
void TVccStateInit::SwitchL(CVccPerformer& aContext)
	{
	RUBY_DEBUG_BLOCKL( "TVccStateInit::SwitchL" );
	
	__ASSERT_DEBUG(aContext.PrimaryCall()!=NULL, User::Invariant());
	__ASSERT_ALWAYS(aContext.PrimaryCall()->State() == 
	          MCCPCallObserver::ECCPStateConnected,User::Leave(KErrAccessDenied));
	
	if ( aContext.PrimaryCall()->Parameters().CallType() == 
	    CCPCall::ECallTypeCSVoice )
		{
		RUBY_DEBUG0( "- make VoIP call" );
		aContext.Notifier().NotifySubscriberL(EVccCsToPsHoStarted, KErrNone);
		CCCECallParameters* params = CCCECallParameters::NewL();
		params->SetCallType( CCPCall::ECallTypePS );
		params->SetServiceId( KErrNone );
		TInt id = KErrNotFound;
		id =  VccSettingsReader::VoIPServiceIdL();
		__ASSERT_ALWAYS(id >= 0, User::Leave(KErrArgument));		
		params->SetServiceId( id );
		HBufC* uri = NULL;
		uri = VccSettingsReader::DomainTransferUriL();
		CleanupStack::PushL(uri);
		__ASSERT_ALWAYS (uri->Length() > 0, User::Leave(KErrArgument));				     
		aContext.CreateSecondaryCallL(*params, *uri, aContext);	
		CleanupStack::PopAndDestroy( uri ); //uri		
		__ASSERT_DEBUG(aContext.SecondaryCall()!=NULL, User::Invariant());
		//-> Set Next State (work around, VoIP should call CallStateChanged 
        //                    only after Dial has returned)
        aContext.SetState(*iCalling);
        User::LeaveIfError(aContext.SecondaryCall()->Dial());
        delete params;
		}
	else
		{
		RUBY_DEBUG0( "- make CS call" );
		aContext.Notifier().NotifySubscriberL(EVccPsToCsHoStarted, KErrNone);
		       
		CCCECallParameters* params = CCCECallParameters::NewL();
		params->SetCallType( CCPCall::ECallTypeCSVoice );
		params->SetServiceId( KErrNone );
		
		TInt id = KErrNotFound;
		id = VccSettingsReader::CSServiceIdL();
		__ASSERT_ALWAYS(id >= 0, User::Leave(KErrArgument));
		params->SetServiceId( id );
		HBufC* number = NULL;
		number = VccSettingsReader::DomainTransferNumberL();
		CleanupStack::PushL( number );
		__ASSERT_ALWAYS (number->Length() > 0, User::Leave(KErrArgument));
		// the events will come to the context
		aContext.CreateSecondaryCallL(*params, *number, aContext); 
		CleanupStack::PopAndDestroy( number ); //number
		__ASSERT_DEBUG(aContext.SecondaryCall()!=NULL, User::Invariant());
        //-> Set Next State (work around, VoIP should call CallStateChanged 
        //                    only after Dial has returned)
        aContext.SetState(*iCalling);
        
        //not used by cs-plugin
		User::LeaveIfError(static_cast<MCCPCSCall*>
		                        (aContext.SecondaryCall())->Dial(KNullDesC8));	
        delete params;
		}
	}