--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/callcontinuity/vcc/src/tvccstateinit.cpp	Mon Jan 18 20:12:36 2010 +0200
@@ -0,0 +1,238 @@
+/*
+* 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;
+		}
+	}