--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/callcontinuity/vcc/src/tvccstatefailing.cpp	Mon Jan 18 20:12:36 2010 +0200
@@ -0,0 +1,179 @@
+/*
+* 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:   Implementation for the VCC Failing state
+*
+*/
+
+
+
+#include "tvccstatefailing.h"
+#include "cvccperformer.h"
+#include "rubydebug.h"
+
+
+
+// -----------------------------------------------------------------------------
+// c'tor
+// -----------------------------------------------------------------------------
+//
+TVccStateFailing::TVccStateFailing()
+	{
+	RUBY_DEBUG_BLOCK( "TVccStateFailing::TVccStateFailing" );	
+	} 
+
+// -----------------------------------------------------------------------------
+// Name
+// -----------------------------------------------------------------------------
+//	
+TUint TVccStateFailing::Name() const
+	{
+	RUBY_DEBUG_BLOCK( "TVccStateFailing::Name" );
+	return KVccStateFailing;
+	}
+
+// -----------------------------------------------------------------------------
+// LinkState
+// -----------------------------------------------------------------------------
+//
+void TVccStateFailing::LinkState( TVccState& aInit )
+	{
+	RUBY_DEBUG_BLOCK( "TVccStateFailing::LinkState" );
+	iInit = &aInit;	
+	}
+	
+// -----------------------------------------------------------------------------
+// CallStateChanged
+// -----------------------------------------------------------------------------
+//	
+void TVccStateFailing::CallStateChanged( CVccPerformer& aContext, 
+                                const MCCPCallObserver::TCCPCallState aState,
+                                MCCPCall* aCall )
+	{
+	RUBY_DEBUG_BLOCK( "TVccStateFailing::CallStateChanged" );
+	InspectChangedStates(aContext, 
+	                        aState, 
+	                        aCall, 
+	                        aContext.CallObserver(), 
+	                        &MCCPCallObserver::CallStateChanged);
+	}
+
+// -----------------------------------------------------------------------------
+// CallStateChangedWithInband
+// -----------------------------------------------------------------------------
+//  
+void TVccStateFailing::CallStateChangedWithInband( CVccPerformer& aContext, 
+                                const MCCPCallObserver::TCCPCallState aState,
+                                MCCPCall* aCall )
+    {
+    RUBY_DEBUG_BLOCK( "TVccStateFailing::CallStateChangedWithInband" );
+    InspectChangedStates(aContext, 
+                            aState, 
+                            aCall, 
+                            aContext.CallObserver(), 
+                            &MCCPCallObserver::CallStateChangedWithInband);  
+    }
+
+// -----------------------------------------------------------------------------
+// From MCCPCallObserver
+// -----------------------------------------------------------------------------
+//
+void TVccStateFailing::ErrorOccurred( CVccPerformer& aContext, 
+                                const TCCPError aError,
+                                MCCPCall* aCall )
+    {
+    RUBY_DEBUG_BLOCK( "TVccStateFailing::ErrorOccurred" );
+    RUBY_DEBUG1( "TVccStateFailing::ErrorOccurred - error: %d", aError );
+    __ASSERT_DEBUG( aContext.CallObserver()!=NULL, User::Invariant() );
+    __ASSERT_DEBUG(aContext.PrimaryCall()!=NULL, User::Invariant());
+    __ASSERT_DEBUG(aCall != NULL, User::Invariant());
+    if( aCall == aContext.PrimaryCall() )
+        {
+        aContext.CallObserver()->ErrorOccurred( aError, aContext.PrimaryCall() );
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// From MCCPCallObserver
+// -----------------------------------------------------------------------------
+//
+void TVccStateFailing::CallEventOccurred(CVccPerformer& aContext, 
+                                const MCCPCallObserver::TCCPCallEvent aEvent,
+                                MCCPCall* aCall )
+    {
+    RUBY_DEBUG_BLOCK( "TVccStateFailing::CallEventOccurred" ); 
+	__ASSERT_DEBUG(aContext.CallObserver()!=NULL, User::Invariant());
+	__ASSERT_DEBUG(aCall != NULL, User::Invariant());
+	__ASSERT_DEBUG(aContext.PrimaryCall()!=NULL, User::Invariant());
+	    
+	if( aCall == aContext.PrimaryCall() )
+	    {
+	    aContext.CallObserver()->CallEventOccurred( aEvent, aContext.PrimaryCall() );
+	    }
+	}
+
+// -----------------------------------------------------------------------------
+// CheckAndMoveToInit
+// -----------------------------------------------------------------------------
+//
+void TVccStateFailing::CheckAndMoveToInit(CVccPerformer& aContext, MCCPCall* aCall,
+                                            const MCCPCallObserver::TCCPCallState aState)
+    {
+       RUBY_DEBUG_BLOCK( "TVccStateFailing::CheckAndmoveToInit" ); 
+        
+       if ( !aContext.SecondaryCall() )
+           {
+           RUBY_DEBUG0( "Secondary call not exist - setting state to init");
+           aContext.SetState(*iInit);
+           }
+       
+ else  if ( aCall == aContext.SecondaryCall() )
+           {
+           if( aState == MCCPCallObserver::ECCPStateDisconnecting || 
+                   aState == MCCPCallObserver::ECCPStateIdle )
+               {
+               RUBY_DEBUG0( "Secondary call is disconnecting or idle - setting state to init");
+               aContext.SetState(*iInit);
+               }
+           }
+     }
+
+// -----------------------------------------------------------------------------
+// InspectChangedStates
+// -----------------------------------------------------------------------------
+//
+void TVccStateFailing::InspectChangedStates (CVccPerformer& aContext, 
+                               const MCCPCallObserver::TCCPCallState aState,
+                               MCCPCall* aCall,
+                               MCCPCallObserver* aCallee,
+                               void( MCCPCallObserver::*aCallback)
+                               (const MCCPCallObserver::TCCPCallState, MCCPCall*))
+    {
+    __ASSERT_DEBUG( aContext.PrimaryCall() != NULL, User::Invariant() );
+    __ASSERT_DEBUG(aCall != NULL, User::Invariant());
+
+    RUBY_DEBUG1("call state is: %d", aState);
+    // Remote party has disconnected the call during the handover
+    if( aState == MCCPCallObserver::ECCPStateDisconnecting &&
+        aCall == aContext.SecondaryCall() )
+        {
+        ReleaseCall(aContext, *aContext.SecondaryCall(), *iInit, KVccHoNok );
+        }
+    else if (aCall == aContext.PrimaryCall())
+        {
+        //events related to the old leg, so pass them to the telephony.
+        (aCallee->*aCallback)( aState, aContext.PrimaryCall());
+        }
+            
+    CheckAndMoveToInit( aContext, aCall, aState );
+    }