// 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:
// CUnsolicitedCommandCallControlHandler. The handler for handling the unsolicited command related to call control

//system include

//user include
#include "unsolicitedcommandcallcontrolhandler.h"
#include <ctsy/ltsy/cctsydispatchercallback.h>
#include "ltsycommondefine.h"
#include "globalphonemanager.h"
#include "unsolicitedparams.h"
#include "atclcc.h"
#include "ltsycallinformationmanager.h"
#include "mslogger.h"

CUnsolicitedCommandCallControlHandler* CUnsolicitedCommandCallControlHandler::NewL(CGlobalPhonemanager& aGloblePhone,
		                                                                           CCtsyDispatcherCallback& aCtsyDispatcherCallback)
	{
	LOGTEXT(_L8("[Ltsy CallControl] Starting CUnsolicitedCommandCallControlHandler::NewL()"));
	
	CUnsolicitedCommandCallControlHandler* self = CUnsolicitedCommandCallControlHandler::NewLC(aGloblePhone, 
			                                                                                   aCtsyDispatcherCallback);
	CleanupStack::Pop(self);
	return self;
	}

CUnsolicitedCommandCallControlHandler* CUnsolicitedCommandCallControlHandler::NewLC(CGlobalPhonemanager& aGloblePhone,
		                                                                            CCtsyDispatcherCallback& aCtsyDispatcherCallback)
	{
	LOGTEXT(_L8("[Ltsy CallControl] Starting CUnsolicitedCommandCallControlHandler::NewLC()"));
	
	CUnsolicitedCommandCallControlHandler* self = new (ELeave) CUnsolicitedCommandCallControlHandler(aGloblePhone, 
			                                                                                         aCtsyDispatcherCallback);
	CleanupStack::PushL(self);
	self->ConstructL();
	return self;
	}

CUnsolicitedCommandCallControlHandler::~CUnsolicitedCommandCallControlHandler()
	{
	LOGTEXT(_L8("[Ltsy CallControl] Starting CUnsolicitedCommandCallControlHandler::~CUnsolicitedCommandCallControlHandler()"));
	}

CUnsolicitedCommandCallControlHandler::CUnsolicitedCommandCallControlHandler(CGlobalPhonemanager& aGloblePhone,
		                                                                     CCtsyDispatcherCallback& aCtsyDispatcherCallback)
																			 :iGlobalPhone(aGloblePhone),
																			  iCtsyDispatcherCallback(aCtsyDispatcherCallback)
	{
	LOGTEXT(_L8("[Ltsy CallControl] Starting CUnsolicitedCommandCallControlHandler::CUnsolicitedCommandCallControlHandler()"));
	}

void CUnsolicitedCommandCallControlHandler::ConstructL()
	{
	LOGTEXT(_L8("[Ltsy CallControl] Starting CUnsolicitedCommandCallControlHandler::ConstructL()"));
	
	iAtClcc = CATClcc::NewL(iGlobalPhone, iCtsyDispatcherCallback);
	
	iAtClcc->AddQueryCallInformationCompleteNotify(this);
	}

void CUnsolicitedCommandCallControlHandler::QueryCallInformationComplete(TInt /*aError*/)
	{
	LOGTEXT(_L8("[Ltsy CallControl] Starting CUnsolicitedCommandCallControlHandler::QueryCallInformationComplete()"));
	
	if (iAtClcc->GetProcessStates() == CATClcc::EProcessOK)
		{
		TInt nCallId = iGlobalPhone.GetCallInfoManager().FindWaitingCallId();
		
		LOGTEXT2(_L8("[Ltsy CallControl] The Waiting Call Id = %d"), nCallId);
		if (KErrNotFound == nCallId)
			{
			iAtClcc->InitVariable();
			return;
			}
		
		//Waiting call information
		TLtsyCallInformation& tWaitingCallInfo(iGlobalPhone.GetCallInfoManager().GetCallInformationByCallId(nCallId));
		
		RMobileCall::TMobileCallInfoV1 tMobileCallInfo;
		
		//Call id
		tMobileCallInfo.iCallId = tWaitingCallInfo.GetCallId();
		
		//Call service
		TLtsyCallInformation::TCallMode tCallService(tWaitingCallInfo.GetCallMode());
		if (TLtsyCallInformation::EVoiceCall == tCallService)
			{
			tMobileCallInfo.iService = RMobilePhone::EVoiceService;
			}
		else if (TLtsyCallInformation::EDataCall == tCallService)
			{
			tMobileCallInfo.iService = RMobilePhone::ECircuitDataService;
			}
		else if (TLtsyCallInformation::EFaxCall == tCallService)
			{
			tMobileCallInfo.iService = RMobilePhone::EFaxService;
			}
		else
			{
			tMobileCallInfo.iService = RMobilePhone::EServiceUnspecified;
			}	
		
		//Call back
		iCtsyDispatcherCallback.CallbackCallControlNotifyIncomingCallInd(KErrNone, tMobileCallInfo);
		
		//Waiting States
		tMobileCallInfo.iStatus = RMobileCall::EStatusRinging;		
		
		//Telephone number
		tMobileCallInfo.iRemoteParty.iRemoteNumber.iTelNumber.Copy(tWaitingCallInfo.GetMobileTelNum());
			
		//Callback
		iCtsyDispatcherCallback.CallbackCallControlNotifyCallInfoChangeInd(KErrNone, tMobileCallInfo);		
		}
	
	//Init iAtCll for reusing it
	iAtClcc->InitVariable();	
	}

void CUnsolicitedCommandCallControlHandler::HandleSimRemoveEvent()
	{
	LOGTEXT(_L8("[Ltsy CallControl] Starting CUnsolicitedCommandCallControlHandler::HandleSimRemoveEvent()"));
	
	TInt nErr = KErrEtelNoCarrier;
	
	for (TInt nCallId = KLtsyMinCallId; nCallId <= KLtsyMaxCallId; nCallId++)
		{
		TLtsyCallInformation& tCallInfo(iGlobalPhone.GetCallInfoManager().GetCallInformationByCallId(nCallId));
		if (TLtsyCallInformation::EUsed == tCallInfo.GetCallIdIsUsedInfo())
			{
			//Notify disconnecting status
			iCtsyDispatcherCallback.CallbackCallControlNotifyCallStatusChangeInd(nErr,
					                                                             nCallId, 
					                                                             RMobileCall::EStatusDisconnecting);				
			
			//Nofity idel status
			iCtsyDispatcherCallback.CallbackCallControlNotifyCallStatusChangeInd(nErr,
					                                                             nCallId, 
					                                                             RMobileCall::EStatusIdle);				
			}
		}
	
	iGlobalPhone.GetCallInfoManager().ResetAllCalInformation();	
	}

void CUnsolicitedCommandCallControlHandler::HandleProductInitEvent()
	{
	LOGTEXT(_L8("[Ltsy CallControl] Starting CUnsolicitedCommandCallControlHandler::HandleProductInitEvent()"));
	
	TInt nErr = KErrEtelNoCarrier;
	
	for (TInt nCallId = KLtsyMinCallId; nCallId <= KLtsyMaxCallId; nCallId++)
		{
		TLtsyCallInformation& tCallInfo(iGlobalPhone.GetCallInfoManager().GetCallInformationByCallId(nCallId));
		if (TLtsyCallInformation::EUsed == tCallInfo.GetCallIdIsUsedInfo())
			{
			//Notify disconnecting status
			iCtsyDispatcherCallback.CallbackCallControlNotifyCallStatusChangeInd(nErr,
					                                                             nCallId, 
					                                                             RMobileCall::EStatusDisconnecting);				
			//Notify idel status
			iCtsyDispatcherCallback.CallbackCallControlNotifyCallStatusChangeInd(nErr,
					                                                             nCallId, 
					                                                             RMobileCall::EStatusIdle);				
			}
		}
	
	iGlobalPhone.GetCallInfoManager().ResetAllCalInformation();		
	}

void CUnsolicitedCommandCallControlHandler::HandleNetworkLostEvent()
	{
	LOGTEXT(_L8("[Ltsy CallControl] Starting CUnsolicitedCommandCallControlHandler::HandleNetworkLostEvent()"));
	
	TInt nErr = KErrEtelNoCarrier;	
	
	for (TInt nCallId = KLtsyMinCallId; nCallId <= KLtsyMaxCallId; nCallId++)
		{
		TLtsyCallInformation& tCallInfo(iGlobalPhone.GetCallInfoManager().GetCallInformationByCallId(nCallId));
		if (TLtsyCallInformation::EUsed == tCallInfo.GetCallIdIsUsedInfo())
			{
			//Notify disconnecting status
			iCtsyDispatcherCallback.CallbackCallControlNotifyCallStatusChangeInd(nErr,
					                                                             nCallId, 
					                                                             RMobileCall::EStatusDisconnecting);				
			//Notify idel status
			iCtsyDispatcherCallback.CallbackCallControlNotifyCallStatusChangeInd(nErr,
					                                                             nCallId, 
					                                                             RMobileCall::EStatusIdle);				
			}
		}
	
	iGlobalPhone.GetCallInfoManager().ResetAllCalInformation();		
	}

void CUnsolicitedCommandCallControlHandler::HandleCallCreatedEvent(const TDesC8& aWindPkg)
	{
	LOGTEXT(_L8("[Ltsy CallControl] Starting CUnsolicitedCommandCallControlHandler::HandleCallCreatedEvent()"));
	
	TUnsolicitedParams::TUnsolicitedParamsPckgBuf* pPckg = (TUnsolicitedParams::TUnsolicitedParamsPckgBuf*)(&aWindPkg);
	TInt nCallId = (*pPckg)().iIdx;
	LOGTEXT2(_L8("[Ltsy CallControl] nCallId = %d"), nCallId);
	
	if (iAtClcc->GetProcessStates() == CATClcc::EProcessNotInProgress)
		{
		TInt nRet = iGlobalPhone.CheckGlobalPhoneStatus();
		if (nRet == KErrNone)
			{
			iGlobalPhone.iEventSignalActive = ETrue;
			iAtClcc->StartRequest();			
			}
		}
	}

void CUnsolicitedCommandCallControlHandler::HandleCallReleasedEvent(const TDesC8& aWindPkg)
	{
	//if call id is incoming call reset incoming call states
	iGlobalPhone.GetCallInfoManager().SetIncomingCallFlag(EFalse);
	
	//Notify CTSY incoming call release
	TUnsolicitedParams::TUnsolicitedParamsPckgBuf* pPckg = (TUnsolicitedParams::TUnsolicitedParamsPckgBuf*)(&aWindPkg);
	TInt nCallId = (*pPckg)().iIdx;		
	LOGTEXT2(_L8("[Ltsy CallControl] nCallId = %d"), nCallId);
	
	if (nCallId >= KLtsyMinCallId && nCallId <= KLtsyMaxCallId)
		{
		TLtsyCallInformation& tCallInfo(iGlobalPhone.GetCallInfoManager().GetCallInformationByCallId(nCallId));
		if (TLtsyCallInformation::EUsed == tCallInfo.GetCallIdIsUsedInfo())
			{
			//Notify disconnecting status
			iCtsyDispatcherCallback.CallbackCallControlNotifyCallStatusChangeInd(KErrGsmCCNormalCallClearing,
																				 nCallId,
																				 RMobileCall::EStatusDisconnecting);			
			//Notify idel status
			iCtsyDispatcherCallback.CallbackCallControlNotifyCallStatusChangeInd(KErrGsmCCNormalCallClearing,
																				 nCallId,
																				 RMobileCall::EStatusIdle);
			
			iGlobalPhone.GetCallInfoManager().ResetCallInformationByCallId(nCallId);
			}
		}	
	}

void CUnsolicitedCommandCallControlHandler::UnsolicitedCommandArriving(TInt aEvent, 
																	   const TDesC8& aWindPkg)
	{
	LOGTEXT(_L8("[Ltsy CallControl] Starting CUnsolicitedCommandCallControlHandler::UnsolicitedCommandArriving()"));
	LOGTEXT2(_L8("[Ltsy CallControl] nEvent = %d"), aEvent);
	
	switch (aEvent)
		{
		case KLtsyUnsolicitedEvent00:
			HandleSimRemoveEvent();
			break;
			
		case KLtsyUnsolicitedEvent03:
			HandleProductInitEvent();
			break;
			
		case KLtsyUnsolicitedEvent08:
			HandleNetworkLostEvent();
			break;
			
		case KLtsyUnsolicitedEvent05:
			HandleCallCreatedEvent(aWindPkg);
			break;
			
		case KLtsyUnsolicitedEvent06:
			HandleCallReleasedEvent(aWindPkg);
			break;
			
		default:
			break;
		}
	
	LOGTEXT(_L8("[Ltsy CallControl] End CUnsolicitedCommandCallControlHandler::UnsolicitedCommandArriving()"));
	}

//End of file