/*

* Copyright (c) 2006-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:   Default implementations for the VCC state machine functions

*

*/

#include "tvccstate.h"

#include "cvccperformer.h"

#include "rubydebug.h"

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

// c'tor

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

//

TVccState::TVccState()

	{

	RUBY_DEBUG_BLOCK( "TVccState::TVccState" );	

	}

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

// User has answered the incoming call

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

//

TInt TVccState::Answer( MCCPCall& aCall )

    {

    RUBY_DEBUG_BLOCK( "TVccState::Answer" );

 	return aCall.Answer();

    }

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

// User has rejected the incoming call

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

//

TInt TVccState::Reject( MCCPCall& aCall )

    {

    RUBY_DEBUG_BLOCK( "TVccState::Reject" );

  	return aCall.Reject();

    }

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

// Queue incoming call

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

//

TInt TVccState::Queue( MCCPCall& aCall )

    {

    RUBY_DEBUG_BLOCK( "TVccState::Queue" );

 	return aCall.Queue();

    }

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

// Dial a new call

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

//

TInt TVccState::Dial( MCCPCall& aCall )

    {

    RUBY_DEBUG_BLOCK( "TVccState::Dial" );

 	return aCall.Dial();

    }

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

// MT call user ringing now

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

//

TInt TVccState::Ringing( MCCPCall& aCall )

    {

    RUBY_DEBUG_BLOCK( "TVccState::Ringing" );

	return aCall.Ringing();

    }

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

// End current call

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

//

TInt TVccState::HangUp( CVccPerformer& /*aContext*/, MCCPCall& aCall )

    {

    RUBY_DEBUG_BLOCK( "TVccState::HangUp" );

    return aCall.HangUp();

    }

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

// Cancel ongoing request

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

//

TInt TVccState::Cancel( MCCPCall& aCall )

    {

    RUBY_DEBUG_BLOCK( "TVccState::Cancel" );

  	return aCall.Cancel();

    }

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

// Hold call

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

//

TInt TVccState::Hold( MCCPCall& aCall )

    {

    RUBY_DEBUG_BLOCK( "TVccState::Hold" );

    return aCall.Hold();

    }

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

// Resume held call

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

//

TInt TVccState::Resume( MCCPCall& aCall )

    {

    RUBY_DEBUG_BLOCK( "TVccState::Resume" );

 	return aCall.Resume();

    }

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

// Swap hold/resume states

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

//

TInt TVccState::Swap( MCCPCall& /*aCall*/ )

    {

    RUBY_DEBUG_BLOCK( "TVccState::Swap" );

    //return aCall.Swap();

    return KErrArgument; //not allowed

    }

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

// Get call recipient

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

//

const TDesC& TVccState::RemoteParty( const MCCPCall& aCall ) const

    {

    RUBY_DEBUG_BLOCK( "TVccState::RemoteParty" );

	return aCall.RemoteParty();

    }

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

// Get call recipient

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

//

const TDesC& TVccState::DialledParty( const MCCPCall& aCall ) const

    {

    RUBY_DEBUG_BLOCK( "TVccState::DialledParty" );

    return aCall.DialledParty();

    }

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

// Is call forwarded or not

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

//

TBool TVccState::IsCallForwarded( const MCCPCall& aCall ) const

    {

    RUBY_DEBUG_BLOCK( "TVccState::IsCallForwarded" );

 	return aCall.IsCallForwarded();

    }

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

// Is call mobile originated or not

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

//

TBool TVccState::IsMobileOriginated( const MCCPCall& aCall ) const

    {

    RUBY_DEBUG_BLOCK( "TVccState::IsMobileOriginated" );

 	return aCall.IsMobileOriginated();

    }

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

// Get current call state

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

//

MCCPCallObserver::TCCPCallState TVccState::State( const MCCPCall& aCall ) const

    {

    RUBY_DEBUG_BLOCK( "TVccState::State" );

 	return aCall.State();

    }

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

// get call capabilities

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

//

MCCPCallObserver::TCCPCallControlCaps TVccState::Caps( const MCCPCall& aCall ) const

    {

    RUBY_DEBUG_BLOCK( "TVccState::Caps" );

 	return aCall.Caps();

    }

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

// SecureSpecified

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

//

TBool TVccState::SecureSpecified( const MCCPCall& aCall ) const

    {

    return aCall.SecureSpecified();

    }

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

// Is call secured

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

//

TBool TVccState::IsSecured( const MCCPCall& aCall ) const

    {

    RUBY_DEBUG_BLOCK( "TVccState::IsSecured" );

    return aCall.IsSecured();

    }

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

// Set paramaters

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

//

void TVccState::SetParameters( const CCCPCallParameters& /*aNewParams*/ )

    {

    RUBY_DEBUG_BLOCK( "TVccState::SetParameters" );

    //not implemented

    }

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

// Get paramaters

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

//

const CCCPCallParameters& TVccState::Parameters( const MCCPCall& aCall ) const

    {

    RUBY_DEBUG_BLOCK( "TVccState::Parameters" );

    return aCall.Parameters();

    }

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

// Return used tone.

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

//

TCCPTone TVccState::Tone( const MCCPCall& aCall ) const

	{

	RUBY_DEBUG_BLOCK( "TVccState::Tone" );

	return aCall.Tone();

	}

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

// Add observer.

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

//

void TVccState::AddObserverL( const MCCPCallObserver& aObserver, 

                              MCCPCall& aCall )

    {

    RUBY_DEBUG_BLOCKL( "TVccState::AddObserverL" );

 	aCall.AddObserverL(aObserver);

    }

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

// Add observer.

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

//

TInt TVccState::RemoveObserver( const MCCPCallObserver& aObserver, 

                                MCCPCall& aCall )

    {

    RUBY_DEBUG_BLOCK( "TVccState::RemoveObserver" );

	return aCall.RemoveObserver(aObserver);

    }

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

// Dial from MCCPCSCall

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

//

TInt TVccState::Dial( const TDesC8& aCallParams, MCCPCSCall& aCall  )

	{

	RUBY_DEBUG_BLOCK( "TVccState::Dial" );

	return aCall.Dial(aCallParams);

	//!!!!!!!!!!!!!!-> check if "if" is really as this cannot be really invoked

	// for non-cs call

	}

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

// NoFDNCheck from MCCPCSCall

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

//

void TVccState::NoFDNCheck( MCCPCSCall& aCall )

	{

	RUBY_DEBUG_BLOCK( "TVccState::NoFDNCheck" );

	aCall.NoFDNCheck();

	}

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

// GetMobileCallInfo from MCCPCSCall

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

//

TInt TVccState::GetMobileCallInfo( TDes8& aCallInfo, 

                                   const MCCPCSCall& aCall ) const

	{

	RUBY_DEBUG_BLOCK( "TVccState::GetMobileCallInfo" );

	return aCall.GetMobileCallInfo(aCallInfo);

	}

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

// SwitchAlternatingCall from MCCPCSCall

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

//

TInt TVccState::SwitchAlternatingCall( MCCPCSCall& aCall )

	{

	RUBY_DEBUG_BLOCK( "TVccState::SwitchAlternatingCall" );

	return aCall.SwitchAlternatingCall();

	}

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

// SwitchAlternatingCall from MCCPCSCall

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

//

TInt TVccState::GetMobileDataCallCaps( TDes8& aCaps, 

                                       const MCCPCSCall& aCall) const

	{

	RUBY_DEBUG_BLOCK( "TVccState::GetMobileDataCallCaps" );

	return aCall.GetMobileDataCallCaps(aCaps);

	}

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

// LogDialedNumber from MCCPCSCall

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

//

TBool TVccState::LogDialedNumber( const MCCPCSCall& aCall ) const

    {

    RUBY_DEBUG_BLOCK( "TVccState::GetMobileDataCallCaps" );

    return aCall.LogDialedNumber();

    }

//  Releases ongoing call

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

//

TInt TVccState::ReleaseCall( MCCPCall& aCall, 

                             RPointerArray<CConvergedCallProvider>& aProvs )

	{

	RUBY_DEBUG_BLOCK( "TVccState::ReleaseCall" );

	TInt err = KErrNotFound;

	for (TUint i=0; i < aProvs.Count(); i++)

		{

		 err = aProvs[i]->ReleaseCall(aCall);

		 if (err == KErrNone)

		 	{

		 	break;

		 	}

		}

	return err;

	}

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

//  Releases ongoing call

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

//

TInt TVccState::ReleaseCall(CVccPerformer& aContext, 

                                MCCPCall& aCall, 

                                TVccState& aState,

                                TUint aHoValue )

	{

	RUBY_DEBUG_BLOCK( "TVccState::ReleaseCall" );

	TInt err = KErrNotFound;

	err = aContext.CsProvider().ReleaseCall(aCall);

	if (err!=KErrNone)

		{

		aContext.PsProvider().ReleaseCall(aCall);

		}

	if( aHoValue == KVccHoNok )

	    {

	    //MT party of the call disconnected the call during HO

	    TRAP_IGNORE(aContext.Notifier().NotifySubscriberL( EVccCsToPsHoFailure, 

	            KErrGeneral ) );

	    }

	else

	    {

	    aContext.HandoverReady();

	    TRAP_IGNORE(aContext.Notifier().NotifySubscriberL(EVccCsToPsHoSuccessful,

                KErrNone) );

	    }

	//-> Set Next State

	aContext.SetState(aState);

	return err;

	}

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

// From MCCPCallObserver

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

//

void TVccState::ErrorOccurred(CVccPerformer& /*aContext*/, 

                            const TCCPError /*aError*/,

                            MCCPCall* /*aCall*/ )

	{

	RUBY_DEBUG_BLOCK( "TVccState::ErrorOccurred" );	

	}

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

// From MCCPCallObserver

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

//

void TVccState::CallStateChanged(CVccPerformer& /*aContext*/, 

                            const MCCPCallObserver::TCCPCallState /*aState*/,

                            MCCPCall* /*aCall*/ )

	{

	RUBY_DEBUG_BLOCK( "TVccState::CallStateChanged" );

	}

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

// From MCCPCallObserver

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

//

void TVccState::CallStateChangedWithInband(CVccPerformer& /*aContext*/, 

                            const MCCPCallObserver::TCCPCallState /*aState*/,

                            MCCPCall* /*aCall*/  )

	{

	RUBY_DEBUG_BLOCK( "TVccState::CallStateChangedWithInband" );

	}

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

// From MCCPCallObserver

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

//

void TVccState::CallEventOccurred(CVccPerformer& /*aContext*/, 

                            const MCCPCallObserver::TCCPCallEvent /*aEvent*/,

                            MCCPCall* /*aCall*/ )

	{

	RUBY_DEBUG_BLOCK( "TVccState::CallEventOccurred" );	

	}

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

// From MCCPCallObserver

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

//

void TVccState::CallCapsChanged(CVccPerformer& aContext, 

                            const TUint32 aCapsFlags,

                            MCCPCall* aCall )

	{

	RUBY_DEBUG_BLOCK( "TVccState::CallCapsChanged" );	

	aContext.CallObserver()->CallCapsChanged( aCapsFlags, aCall );

	}

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

// SwitchL()

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

//

void TVccState::SwitchL(CVccPerformer& /*aContext*/)

	{

	RUBY_DEBUG_BLOCK( "TVccState::SwitchL" );

	User::Leave(KErrCompletion);

	}