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

//

#include <commsdattypesv1_1.h>

#include "CALL.H"		// Header file for this source file

#include "NOTIFY.H"

#include "ATDIAL.H"

#include "ATANSWER.H"

#include "ATCONNCT.H"

#include "ATHANGUP.H"

#include "ATO.H"

#include "ATNOCARR.H"

#include "LINE.H"

#include "ATINIT.H"

#include "mSLOGGER.H"	// for LOGTEXT untilities

#include "ATIO.H"		// For CATIO class

#include "PHONE.H"

#include <et_clsvr.h>

#include "ATBASE.H"

#include "Matstd.h"		// For AT command string constants 

#include "set_cbst.h"		// for CATSetCBST class

#include "et_struct.h"

//

// CAcquireEntry class

//

CAcquireEntry* CAcquireEntry::NewL(const TTsyReqHandle aTsyReqHandle)

//

// Create new request entry

//

	{

	return new(ELeave) CAcquireEntry(aTsyReqHandle);

	}

CAcquireEntry::CAcquireEntry(const TTsyReqHandle aTsyReqHandle)

//

// Constructor

//

	{

	iTsyReqHandle=aTsyReqHandle;

	}

CAcquireEntry::~CAcquireEntry()

//

// Destructor

//

	{}

void CAcquireEntry::Deque()

//

// Deque List

//

	{

	iLink.Deque();

	iLink.iPrev=iLink.iNext=NULL;

	}

CAcquireOwnerList::CAcquireOwnerList()

	{}

CAcquireOwnerList::~CAcquireOwnerList()

	{}

CAcquireOwnerList* CAcquireOwnerList::NewL()

//

//	Static function to create new acquire owner list

//

	{

	CAcquireOwnerList* self=new(ELeave) CAcquireOwnerList();

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

void CAcquireOwnerList::ConstructL()

	{

	iAcquireList.SetOffset(_FOFF(CAcquireEntry,iLink));

	}

CAcquireEntry* CAcquireOwnerList::FindByTsyReqHandle(const TTsyReqHandle aTsyReqHandle)

//

//	Searches for client interested in taking ownership of call, by its TsyReqHandle

//

	{

	CAcquireEntry* entry;

	TDblQueIter<CAcquireEntry> iter(iAcquireList);

	while(entry = iter++, entry!=NULL)

		{

		if(entry->iTsyReqHandle==aTsyReqHandle)

			return entry;

		}

	return NULL;

	}

void CAcquireOwnerList::Remove(CAcquireEntry* aEntry)

	{

	aEntry->Deque();

	delete aEntry;

	}

//

//	CHeartbeatRunner - periodic class to count seconds from beginning of call

//

CHeartbeatRunner* CHeartbeatRunner::NewL(CCallHayes* aCallHayes,CNotifications* aNotificationStore)

	{

	CHeartbeatRunner* self=new (ELeave) CHeartbeatRunner(aCallHayes,aNotificationStore);

	CleanupStack::PushL(self);

    self->ConstructL();

	CleanupStack::Pop();

    return self;

	}

CHeartbeatRunner::CHeartbeatRunner(CCallHayes* aCallHayes,CNotifications* aNotificationStore)

	:iCallHayes(aCallHayes), iNotificationStore(aNotificationStore)

	{}

void CHeartbeatRunner::ConstructL()

	{

	iHeartbeat=CHeartbeat::NewL(0); // neutral priority

	}

CHeartbeatRunner::~CHeartbeatRunner()

	{

	if (iHeartbeat != NULL)

		iHeartbeat->Cancel();

    delete iHeartbeat;

	}

void CHeartbeatRunner::Start()

	{

	iStartTime.UniversalTime();

	iHeartbeat->Start(ETwelveOClock,this);

	}

void CHeartbeatRunner::Stop()

	{

	iHeartbeat->Cancel();

	iTicks=0;

	}

TTimeIntervalSeconds CHeartbeatRunner::CallDuration() const

	{

	TTimeIntervalSeconds duration(iTicks);

	return duration;

	}

// private functions

void CHeartbeatRunner::Beat()

	{

	iTicks++;

	iNotificationStore->CheckNotification(iCallHayes,ETimePeriodElapsed);

	}

void CHeartbeatRunner::Synchronize()

	{

	TInt ticksMissed = 0;

	TTime desiredTime = iStartTime + TTimeIntervalMicroSeconds(iTicks * KCallTimerInterval);

	TTime currentTime; // set current time to now

	currentTime.UniversalTime();

	TTimeIntervalMicroSeconds missedTime = currentTime.MicroSecondsFrom(desiredTime);

	// Calculate the ticks missed (quickly!)

	TInt64 missedTimeInt = missedTime.Int64(); // convert the missed time interval to an Int64

	ticksMissed = I64INT(missedTimeInt / KCallTimerInterval);

	// The following loop increments the ticks missed by the same amount, but takes much longer

	// while (desiredTime < currentTime)

	//	{

	//	desiredTime = desiredTime - TTimeIntervalMicroSeconds(iTickInterval);

	//	ticksMissed++;

	//	}

	iTicks = iTicks + ticksMissed;

	LOGTEXT3(_L8("Heartbeat function synchronising - from %d to %d"),iTicks-ticksMissed,iTicks);

	if (ticksMissed!=0)

		iNotificationStore->CheckNotification(iCallHayes,ETimePeriodElapsed);

	}

//

// CCallHayes - General Call Functionality

//

void CCallHayes::CloseCall(TAny* aObj)

//

// Utility func for cleanup stack

//

	{

	((CObject*)aObj)->Close();

	}

CCallHayes::CCallHayes(CATIO* aIo,CATInit* aInit,CPhoneGlobals* aPhoneGlobals) 

			: iPhoneGlobals(aPhoneGlobals),iIo(aIo),iInit(aInit)

	{}

void CCallHayes::ConstructL(const TName& aName)

//

//	Initialise Call Information

//

	{

	LOGTEXT(_L8("Entered CCallHayes::ConstructL()"));

	iCallInfo.iCallName = aName;

	iCallInfo.iBearerService.iBearerCaps = RCall::KBearerCapsCompressionUnknown | RCall::KBearerCapsProtocolUnknown;

	iCallInfo.iBearerService.iBearerSpeed = RCall::EBearerDataUnknown;

	iCallInfo.iHookStatus = RCall::EHookStatusOn;

	iCallInfo.iClientPanicOccurred = ENoPanicOccurred;

	//	Read default call preferences from database

	GetDefaultCallParams();

	iCallInfo.iLoanedToClient = EFalse;

	if (iPhoneGlobals->iPhoneStatus.iLineStatus == RCall::EStatusRinging)

		{

		iCallInfo.iMobileStatus = RMobileCall::EStatusRinging;

		}

	else

		{

		iCallInfo.iMobileStatus = RMobileCall::EStatusIdle;

		}

	iQuickInit=CATQuickInit::NewL(iIo,this,iPhoneGlobals);

	iWaitForNoCarrier=CATWaitForNoCarrier::NewL(iIo,this,iPhoneGlobals);

	iList=CAcquireOwnerList::NewL();

	iCallTimer = CHeartbeatRunner::NewL(this,iPhoneGlobals->iNotificationStore);

	LOGTEXT2(_L8("iCallTimer = %x"),iCallTimer);

	}

CCallHayes::~CCallHayes()

	{

	LOGTEXT(_L8("Entered CCallHayes destructor"));

	if (Owner())

		REINTERPRET_CAST(CLineHayes*,Owner())->RemoveCall(this);

	iPhoneGlobals->iNotificationStore->RemoveClientFromLastEvents(this);

	delete iWaitForNoCarrier;

	delete iList;

	delete iQuickInit;

	delete iCallTimer;

	}

CTelObject::TReqMode CCallHayes::ReqModeL(const TInt aIpc)

	{

	TReqMode reqMode = CCallBase::ReqModeL(aIpc);

	if ((reqMode & KReqModeFlowControlObeyed || aIpc==EEtelCallAnswer) && iPhoneGlobals->iPhoneStatus.iDataPortLoaned)

		{

		LOGTEXT2(_L8("ReqModeL Leaving with KErrInUse as data port is loaned (aIpc=%d)"),aIpc);

		User::Leave(KErrInUse);

		}

	return reqMode;

	}

TInt CCallHayes::RegisterNotification(const TInt /*aIpc*/)

	{

	return KErrNone;

	}

TInt CCallHayes::DeregisterNotification(const TInt /*aIpc*/)

	{

	return KErrNone;

	}

void CCallHayes::Init()

//

//	Only CPhoneHayes::Init() is implemented as that is called first

//

	{}

TInt CCallHayes::NotifyCapsChange(const TTsyReqHandle aTsyReqHandle, RCall::TCaps* aCaps)

	{

	LOGTEXT(_L8("Call:\tCaps Change Notification lodged"));

	iPhoneGlobals->iNotificationStore->RegisterNotification(ECallCaps,aTsyReqHandle,this,aCaps);

	return KErrNone;

	}

TInt CCallHayes::NotifyCapsChangeCancel(const TTsyReqHandle aTsyReqHandle)

	{

	LOGTEXT(_L8("Call:\tCaps Change Notification cancelled"));

	iPhoneGlobals->iNotificationStore->RemoveNotification(aTsyReqHandle);

	return KErrNone;

	}

TInt CCallHayes::NotifyHookChange(const TTsyReqHandle aTsyReqHandle, RCall::THookStatus* aHookStatus)

	{

	LOGTEXT(_L8("Call:\tHook Change Notification lodged"));

	iPhoneGlobals->iNotificationStore->RegisterNotification(ECallHookChange,aTsyReqHandle,this,aHookStatus);

	return KErrNone;

	}

TInt CCallHayes::NotifyHookChangeCancel(const TTsyReqHandle aTsyReqHandle)

	{

	LOGTEXT(_L8("Call:\tHook Change Notification cancelled"));

	iPhoneGlobals->iNotificationStore->RemoveNotification(aTsyReqHandle);

	return KErrNone;

	}

TInt CCallHayes::NotifyStatusChange(const TTsyReqHandle aTsyReqHandle,RCall::TStatus* aStatus)

	{

	LOGTEXT(_L8("Call:\tStatus Change Notification lodged"));

	iPhoneGlobals->iNotificationStore->RegisterNotification(ECallStatusChange,aTsyReqHandle,this,aStatus);

	return KErrNone;

	}

TInt CCallHayes::NotifyStatusChangeCancel(const TTsyReqHandle aTsyReqHandle)

	{

	LOGTEXT(_L8("Call:\tStatus Change Notification cancelled"));

	iPhoneGlobals->iNotificationStore->RemoveNotification(aTsyReqHandle);

	return KErrNone;

	}

TInt CCallHayes::NotifyDurationChange(const TTsyReqHandle aTsyReqHandle,TTimeIntervalSeconds* aTime)

	{

	LOGTEXT(_L8("Call:\tDuration Change Notification lodged"));

	iPhoneGlobals->iNotificationStore->RegisterNotification(ECallDurationChange,aTsyReqHandle,this,aTime);

	return KErrNone;

	}

TInt CCallHayes::NotifyDurationChangeCancel(const TTsyReqHandle aTsyReqHandle)

	{

	LOGTEXT(_L8("Call:\tDuration Change Notification cancelled"));

	iPhoneGlobals->iNotificationStore->RemoveNotification(aTsyReqHandle);

	return KErrNone;

	}

TInt CCallHayes::GetInfo(const TTsyReqHandle aTsyReqHandle, RCall::TCallInfo* aCallInfo)

	{

	aCallInfo->iCallName = iCallInfo.iCallName;

	aCallInfo->iStatus = GetCoreCallStatus();

	aCallInfo->iHookStatus = iCallInfo.iHookStatus;

	aCallInfo->iLineName = Owner()->Name();

	GetCallDuration(aCallInfo->iDuration);

	ReqCompleted(aTsyReqHandle,KErrNone);

	return KErrNone;

	}

TInt CCallHayes::GetStatus(const TTsyReqHandle aTsyReqHandle, RCall::TStatus* aCallStatus)

    {

	LOGTEXT(_L8("Call:\tGetStatus() called"));

	*aCallStatus = GetCoreCallStatus();

	ReqCompleted(aTsyReqHandle,KErrNone);

    return KErrNone;

    }

TInt CCallHayes::TransferOwnership(const TTsyReqHandle aTsyReqHandle)

//

// Transfer call ownership

//

	{

	LOGTEXT(_L8("Call:\tTransferOwnership called"));

	if (CheckOwnership(aTsyReqHandle)!=CCallBase::EOwnedTrue)

		{

		ReqCompleted(aTsyReqHandle,KErrEtelNotCallOwner);

		return KErrNone;

		}

	if(iList->iAcquireList.IsEmpty()) // no one interested in this call !

		{

		ReqCompleted(aTsyReqHandle,KErrEtelNoClientInterestedInThisCall);

		return KErrNone;

		}

	CAcquireEntry* entry=iList->iAcquireList.First();

	if (entry) // someone interested in this call

		{

		LOGTEXT(_L8("Call:\tTransferOwnership successful"));

		(void)SetOwnership(entry->iTsyReqHandle);

		ReqCompleted(entry->iTsyReqHandle,KErrNone);

		iList->Remove(entry);

		ReqCompleted(aTsyReqHandle,KErrNone);

		}

	return KErrNone;

	}

TInt CCallHayes::AcquireOwnership(const TTsyReqHandle aTsyReqHandle)

//

//	Acquire call Ownership (server has already checked client does not own it)

//	If call is unowned and idle, this request is completed with CallNotActive.

//  A call must never be owned and idle concurrently.

//

	{

	LOGTEXT(_L8("Call:\tAcquireOwnership called"));

	if (CheckOwnership(aTsyReqHandle)==CCallBase::EOwnedUnowned)

		{

		LOGTEXT(_L8("Call:\tAcquireOwnership unsuccessful as call is not owned already"));

		ReqCompleted(aTsyReqHandle,KErrEtelCallNotActive);

		}

	else 

		{

		if(iList->iAcquireList.IsEmpty())

			// List is empty. Client is the first one to request ownership of the call.

			{

			CAcquireEntry* entry=NULL;

			TRAPD(err,entry=CAcquireEntry::NewL(aTsyReqHandle));

			if(err==KErrNone)

				iList->iAcquireList.AddLast(*entry);

			else

				return err;

			}

		else

			// List is not empty. Another client has already requested to acquire ownership of the call.

			// Only one client can be waiting to acquire ownership at any one time.

			return KErrInUse;

		}

	return KErrNone;

	}

TInt CCallHayes::AcquireOwnershipCancel(const TTsyReqHandle aTsyReqHandle)

//

//	Cancel Acquire call Ownership

//

	{

	CAcquireEntry* entry=iList->FindByTsyReqHandle(aTsyReqHandle);

	__ASSERT_ALWAYS(entry!=NULL,Panic(EAcquirerNotFound));

	if (entry != NULL)

		{

		iList->Remove(entry);

		ReqCompleted(aTsyReqHandle, KErrCancel);

		}

	else

		{

		ReqCompleted(aTsyReqHandle, KErrNotFound);

		}					

	return KErrNone;		

	}

TInt CCallHayes::GetBearerServiceInfo(const TTsyReqHandle aTsyReqHandle,RCall::TBearerService* aBearerService)

	{

	*aBearerService = iCallInfo.iBearerService;

	ReqCompleted(aTsyReqHandle,KErrNone);

	return KErrNone;

	}

TInt CCallHayes::GetCallParams(const TTsyReqHandle aTsyReqHandle, TDes8* aParams)

//

// Call parameters are only set when connecting a call, so there have no meaning when a 

// call is not in progress.

//

	{

	if (RMobileCall::EStatusIdle != iCallInfo.iMobileStatus  &&

		RMobileCall::EStatusUnknown != iCallInfo.iMobileStatus )

		{

		TPckg<RCall::TCallParams>* paramsPckg = (TPckg<RCall::TCallParams>*)aParams;

		RCall::TCallParams& callparams = (*paramsPckg)();

		//

		// Configure basic TCallParams parameters

		callparams.iSpeakerControl = iCallInfo.iSpeakerControl;

		callparams.iSpeakerVolume = iCallInfo.iSpeakerVolume;

		callparams.iInterval = iCallInfo.iInterval;

		callparams.iWaitForDialTone = iCallInfo.iWaitForDialTone;

		//

		// Configure additional params as required

		if(callparams.ExtensionId()==RMobileCall::KETelMobileCallParamsV1)

			{

			//

			// Configure RMobileCall::TMobileCallParamsV1 parameters

			RMobileCall::TMobileCallParamsV1Pckg* pckg = (RMobileCall::TMobileCallParamsV1Pckg*)aParams;

			RMobileCall::TMobileCallParamsV1& params = (*pckg)();

			params.iIdRestrict=iCallInfo.iCallParams.iIdRestrict;

			params.iCug=iCallInfo.iCallParams.iCug;

			params.iAutoRedial=iCallInfo.iCallParams.iAutoRedial;

			}

		else if(callparams.ExtensionId()==RMobileCall::KETelMobileDataCallParamsV1)

			{

			//

			// Configure RMobileCall::TMobileDataCallParamsV1 parameters

			RMobileCall::TMobileDataCallParamsV1Pckg* pckg = (RMobileCall::TMobileDataCallParamsV1Pckg*)aParams;

			RMobileCall::TMobileDataCallParamsV1& params = (*pckg)();

			params.iService=iCallInfo.iCallParams.iService;

			params.iSpeed=iCallInfo.iCallParams.iSpeed;

			params.iProtocol=iCallInfo.iCallParams.iProtocol;

			params.iQoS=iCallInfo.iCallParams.iQoS;

			params.iRLPVersion=iCallInfo.iCallParams.iRLPVersion;

			params.iModemToMSWindowSize=iCallInfo.iCallParams.iModemToMSWindowSize;

			params.iMSToModemWindowSize=iCallInfo.iCallParams.iMSToModemWindowSize;

			params.iAckTimer=iCallInfo.iCallParams.iAckTimer;

			params.iRetransmissionAttempts=iCallInfo.iCallParams.iRetransmissionAttempts;

			params.iResequencingPeriod=iCallInfo.iCallParams.iResequencingPeriod;

			params.iV42bisReq=iCallInfo.iCallParams.iV42bisReq;

			params.iV42bisCodewordsNum=iCallInfo.iCallParams.iV42bisCodewordsNum;

			params.iV42bisMaxStringLength=iCallInfo.iCallParams.iV42bisMaxStringLength;

			}

		else if(callparams.ExtensionId()==RMobileCall::KETelMobileHscsdCallParamsV1)

			{

			//

			// Configure RMobileCall::TMobileHscsdCallParamsV1 parameters

			RMobileCall::TMobileHscsdCallParamsV1Pckg* pckg = (RMobileCall::TMobileHscsdCallParamsV1Pckg*)aParams;

			RMobileCall::TMobileHscsdCallParamsV1& params = (*pckg)();

			params.iWantedAiur=iCallInfo.iCallParams.iWantedAiur;

			params.iWantedRxTimeSlots=iCallInfo.iCallParams.iWantedRxTimeSlots;

			params.iMaxTimeSlots=iCallInfo.iCallParams.iMaxTimeSlots;

			params.iCodings=iCallInfo.iCallParams.iCodings;

			params.iAsymmetry=iCallInfo.iCallParams.iAsymmetry;

			params.iUserInitUpgrade=iCallInfo.iCallParams.iUserInitUpgrade;

			}

		//

		// Complete the clients request

		ReqCompleted(aTsyReqHandle,KErrNone);

		}

	else 

		{

		ReqCompleted(aTsyReqHandle,KErrUnknown);

		}

	return KErrNone;

	}

TInt CCallHayes::GetCallDuration(const TTsyReqHandle aTsyReqHandle, TTimeIntervalSeconds* aTime)

	{

	if ( RMobileCall::EStatusConnected != iCallInfo.iMobileStatus && 

		 RMobileCall::EStatusDisconnecting != iCallInfo.iMobileStatus)

		{

		ReqCompleted(aTsyReqHandle,KErrEtelCallNotActive);

		return KErrNone;

		}

	*aTime = iCallTimer->CallDuration();

	ReqCompleted(aTsyReqHandle,KErrNone);

	return KErrNone;

	}