// Copyright (c) 2009 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:

// Hangup a ongoning call

//system include

//user include

#include "athangup.h"

#include "atmanager.h"

#include "activecommandstore.h"

#include "mslogger.h"

#include "ltsycallinformationmanager.h"

#include "allcallreleasecompleteobserver.h"

//const define

const TInt KLtsyHangupReadTimeout = 2;

_LIT8(KLtsyHangUpAllCallCommand, "ATH\r"); //ATH0

CATHangUp* CATHangUp::NewL(CGlobalPhonemanager& aGloblePhone,

			               CCtsyDispatcherCallback& aCtsyDispatcherCallback)

	{

	LOGTEXT(_L8("[Ltsy CallControl] Starting CATHangUp::NewL()"));

	CATHangUp* self = CATHangUp::NewLC(aGloblePhone, aCtsyDispatcherCallback);

	CleanupStack::Pop(self);

	return self;

	}

CATHangUp* CATHangUp::NewLC(CGlobalPhonemanager& aGloblePhone,

			               CCtsyDispatcherCallback& aCtsyDispatcherCallback)

	{

	LOGTEXT(_L8("[Ltsy CallControl] Starting CATHangUp::NewLC()"));

	CATHangUp* self = new (ELeave) CATHangUp(aGloblePhone, aCtsyDispatcherCallback);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

CATHangUp::~CATHangUp()

	{

	LOGTEXT(_L8("[Ltsy CallControl] Starting CATHangUp::~CATHangUp()"));

	}

CATHangUp::CATHangUp(CGlobalPhonemanager& aGloblePhone,

		             CCtsyDispatcherCallback& aCtsyDispatcherCallback)

					 :CAtCommandBase(aGloblePhone, aCtsyDispatcherCallback)

	{

	LOGTEXT(_L8("[Ltsy CallControl] Starting CATHangUp::CATHangUp()"));

	iAtType = ELtsyAT_Call_ATH;

	iIOStatus = KErrNone;

	iATResult = KErrNone;

	iHangupStep = EATHangUpNotInProgress;

	iHangupOperator = EUnknownAPI;

	iAllCallReleaseObserver = NULL;

	}

void CATHangUp::ConstructL()

	{

	LOGTEXT(_L8("[Ltsy CallControl] Starting CATHangUp::ConstructL()"));

	//Invoke base class function

	CAtCommandBase::ConstructL();

	//Set read and write timeout

	SetTimeOut(KLtsyDefaultWriteTimeOut, KLtsyHangupReadTimeout);

	}

void CATHangUp::ExecuteCommand()

	{

	LOGTEXT(_L8("[Ltsy CallControl] Starting CATHangUp::ExecuteCommand()"));

	iTxBuffer.Copy(KLtsyHangUpAllCallCommand);

	Write();

	iHangupStep = EATHangUpWaitForWriteComplete;

	}

void CATHangUp::StartRequest()

	{

	LOGTEXT(_L8("[Ltsy CallControl] Starting CATHangUp::StartRequest()"));

	ExecuteCommand();

	}

void CATHangUp::AddAllCallReleaseObserver(MAllCallReleaseCompleteObserver* aObserver)

	{

	LOGTEXT(_L8("[Ltsy CallControl] Starting CATHangUp::AddAllCallReleaseObserver()"));

	iAllCallReleaseObserver = aObserver;

	}

void CATHangUp::InitVariable()

	{

	iAtType = ELtsyAT_Call_ATH;

	iIOStatus = KErrNone;

	iATResult = KErrNone;

	iHangupStep = EATHangUpNotInProgress;

	iHangupOperator = EUnknownAPI;	

	}

void CATHangUp::SetHangupOperator(THangupOperator aOperator)

	{

	LOGTEXT(_L8("[Ltsy CallControl] Starting CATHangUp::SetHangupOperator()"));

	iHangupOperator = aOperator;

	}

void CATHangUp::HandleIOError()

	{

	LOGTEXT(_L8("[Ltsy CallControl] Starting CATHangUp::HandleIOError()"));

	if (iHangupOperator == ECustomAPI)

		{

		iCtsyDispatcherCallback.CallbackCallControlTerminateAllCallsComp(iIOStatus);

		}

	else if (iHangupOperator == ERMobilePhoneAPI)

		{

		iCtsyDispatcherCallback.CallbackPhoneTerminateAllCallsComp(iIOStatus);

		}

	else

		{

		LOGTEXT(_L8("[Ltsy CallControl] Hangup unknown operator!!!!"));

		}

	}

void CATHangUp::HandleResponseError()

	{

	LOGTEXT(_L8("[Ltsy CallControl] Starting CATHangUp::HandleResponseError()"));

	if (iHangupOperator == ECustomAPI)

		{

		iCtsyDispatcherCallback.CallbackCallControlTerminateAllCallsComp(iATResult);

		}

	else if (iHangupOperator == ERMobilePhoneAPI)

		{

		iCtsyDispatcherCallback.CallbackPhoneTerminateAllCallsComp(iATResult);

		}

	else

		{

		LOGTEXT(_L8("[Ltsy CallControl] Hangup unknown operator!!!!"));

		}

	}

void CATHangUp::HandleDisconnectedComplete()

	{

	LOGTEXT(_L8("[Ltsy CallControl] Starting CATHangUp::HandleDisconnectedComplete()"));

	if (iHangupOperator == ECustomAPI)

		{

		iCtsyDispatcherCallback.CallbackCallControlTerminateAllCallsComp(iATResult);

		}

	else if (iHangupOperator == ERMobilePhoneAPI)

		{

		iCtsyDispatcherCallback.CallbackPhoneTerminateAllCallsComp(iATResult);

		}

	else 

		{

		LOGTEXT(_L8("[Ltsy CallControl] Hangup unknown operator!!!!"));

		if (iAllCallReleaseObserver == NULL)

			{

			return;

			}

		}

	//Notify CTSY all call idel

	for (TInt n = KLtsyMinCallId; n <= KLtsyMaxCallId; n++)

		{

		TLtsyCallInformation& tCallInfo(iPhoneGlobals.GetCallInfoManager().GetCallInformationByCallId(n));

		if (tCallInfo.GetCallIdIsUsedInfo() == TLtsyCallInformation::EUsed)

			{

			if (tCallInfo.GetCallState() == TLtsyCallInformation::EInComingCall ||

				tCallInfo.GetCallState() == TLtsyCallInformation::EWaitingCall	)

				{

				iCtsyDispatcherCallback.CallbackCallControlNotifyCallStatusChangeInd(KErrGsmCCCallRejected, 

						                                                             n, 

						                                                             RMobileCall::EStatusDisconnecting);			

				iCtsyDispatcherCallback.CallbackCallControlNotifyCallStatusChangeInd(KErrGsmCCCallRejected, 

																					 n,

																					 RMobileCall::EStatusIdle);				

				}

			else

				{

				iCtsyDispatcherCallback.CallbackCallControlNotifyCallStatusChangeInd(KErrGsmCCNormalCallClearing, 

						                                                             n, 

						                                                             RMobileCall::EStatusDisconnecting);			

				iCtsyDispatcherCallback.CallbackCallControlNotifyCallStatusChangeInd(KErrGsmCCNormalCallClearing, 

																					 n,

																					 RMobileCall::EStatusIdle);				

				}

			}		

		}

	//Setting all call id state unused

	iPhoneGlobals.GetCallInfoManager().ResetAllCalInformation();

	}

void CATHangUp::ParseResponseL(const TDesC8& aResponseBuf)

	{

	LOGTEXT(_L8("[Ltsy CallControl] Starting CATHangUp::ParseResponseL()"));

	if (aResponseBuf.Match(KLtsyOkString) == 0)

		{

		LOGTEXT(_L8("[Ltsy CallControl] Hang up call reponse is OK"));

		iATResult = KErrNone;

		}

	else if (aResponseBuf.Match(KLtsyErrorString) == 0)

		{

		LOGTEXT(_L8("[Ltsy CallControl] Hang up call reponse is Error"));

		iATResult = KErrArgument;

		}

	}

void CATHangUp::Complete()

	{

	LOGTEXT(_L8("[Ltsy CallControl] Starting CATHangUp::Complete()"));

	LOGTEXT2(_L8("[Ltsy CallControl] iIOStatus = %d"), iIOStatus);

	LOGTEXT2(_L8("[Ltsy CallControl] iATResult = %d"), iATResult);

	//Remove Ative Command and stop timer

	CAtCommandBase::Complete();

	//Let other command can use I/O port

	if (iAllCallReleaseObserver == NULL)

		{

		iPhoneGlobals.iEventSignalActive = EFalse;

		}

	else

		{

		if (iIOStatus != KErrNone)

			{

			iAllCallReleaseObserver->ReleaseAllCallComplete(iIOStatus);

			}

		else

			{

			iAllCallReleaseObserver->ReleaseAllCallComplete(iATResult);

			}

		}

	}

void CATHangUp::EventSignal(TAtEventSource /*aEventSource*/, TInt aStatus)

	{

	LOGTEXT(_L8("[Ltsy CallControl] Starting CATHangUp::EventSignal()"));

	LOGTEXT2(_L8("[Ltsy CallControl] aEventSource = %d\taStatus = %d"),aStatus);

	iIOStatus = aStatus;

	if (iIOStatus != KErrNone)

		{

		HandleIOError();

		Complete();

		return;

		}

	switch (iHangupStep)

		{

		case EATHangUpWaitForWriteComplete:

			iHangupStep = EATHangUpReadComplete;

			break;

		case EATHangUpReadComplete:

			if (iATResult == KErrNone)

				{

				HandleDisconnectedComplete();

				}

			else

				{

				HandleResponseError();

				}

			Complete();

			break;

		default:

			break;

		}

	}

//End of file