// 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 "PHONE.H"

#include "LINE.H"

#include "CALL.H"

#include "mSLOGGER.H"

#include "ATINIT.H"

#include "NOTIFY.H"

#include "et_struct.h"

//

// Dummy function is necessary so that compiler knows how to expand a TPckg<RLine::TLineInfo>

//

void CLineHayes::Dummy1()

	{

	RLine::TLineInfo dummy0;

	TPckg<RLine::TLineInfo> dummy1(dummy0);

	dummy1.Zero();

	}

//

// CLineHayes

// General Line Functionality

//

void CLineHayes::CloseLine(TAny* aObj)

//

// Utility func for cleanup stack

//

	{

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

	}

CLineHayes::CLineHayes(CATIO* aATIO,CATInit* aInit,CPhoneGlobals* aPhoneGlobals) : iIo(aATIO)

													,iInit(aInit),iPhoneGlobals(aPhoneGlobals)

	{}

void CLineHayes::ConstructL(const TName& aName)

	{

	LOGTEXT(_L8("CLineHayes::ConstructL()"));

	iLineName = aName;

	iCalls.SetOffset(_FOFF(CCallEntry,iLink));

	iSizeOfMemberData = new(ELeave) CArrayFixFlat<TInt>(4);

	}

void CLineHayes::AppendNewCallL(CCallHayes* aNewCall)

	{

	CCallEntry* entry = CCallEntry::NewL(aNewCall);

	iCalls.AddLast(*entry);

	}

CLineHayes::~CLineHayes()

	{

	LOGTEXT(_L8("CLineHayes Destructor"));

	if (Owner())

		((CPhoneHayes*)Owner())->RemoveLine(this);

	iPhoneGlobals->iNotificationStore->RemoveClientFromLastEvents(this);

	if (iSizeOfMemberData!=NULL)

		iSizeOfMemberData->Reset();

	delete iSizeOfMemberData;

	CCallEntry* callEntry;

	TDblQueIter<CCallEntry> iter(iCalls);

	if (!(iCalls.IsEmpty()))

		{

		while (callEntry=iter++, callEntry)

			{

			if (callEntry->iCallHayes->IsOwnedByTSY())

				{

				callEntry->Deque();

				callEntry->iCallHayes->Close();

				delete callEntry;

				__ASSERT_ALWAYS(iCalls.IsEmpty(),Panic(ECalls_Remaining));

				return;	// there should not be an iPreAlloc if one of the calls in the list was still

						// owned by the TSY (ie no client had taken a handle on it)

				}

			}

		}

	if (iPreAlloc)

		{

		__ASSERT_ALWAYS(iPreAlloc,Panic(EPreAllocatedCallDoesNotExist));

		iPreAlloc->iCallHayes->Close();

		delete iPreAlloc;

		}

	}

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

	{

	TReqMode reqMode = CLineBase::ReqModeL(aIpc);

	if ((reqMode & KReqModeFlowControlObeyed) && iPhoneGlobals->iPhoneStatus.iDataPortLoaned)

		{

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

		User::Leave(KErrInUse);

		}

	return reqMode;

	}

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

	{

	return KErrNone;

	}

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

	{

	return KErrNone;

	}

void CLineHayes::Init()

	{}

TInt CLineHayes::NotifyIncomingCall(const TTsyReqHandle aTsyReqHandle, TName* aName)

	{

	iPhoneGlobals->iNotificationStore->RegisterNotification(EIncomingCall,aTsyReqHandle,this,aName);

	LOGTEXT(_L8("Line:\tIncoming Call Notification lodged"));

	iNotifyIncomingCallOutstanding=ETrue;

	CCallEntry* callEntry;

	TDblQueIter<CCallEntry> iter(iCalls);

	while (callEntry=iter++, callEntry)

		{

		if ((callEntry->iCallHayes->CallInfo())->iMobileStatus==RMobileCall::EStatusRinging)

			{

			iPhoneGlobals->iNotificationStore->CheckNotification(callEntry->iCallHayes,ERingOccurred);

			break;

			}

		}

	if (iPhoneGlobals->iPhoneStatus.iInitStatus==EPhoneNotInitialised)

		{

		FlowControlSuspend();

		iInit->SpecialStart();

		}

	return KErrNone;

	}

TInt CLineHayes::NotifyIncomingCallCancel(const TTsyReqHandle aTsyReqHandle)

	{

	LOGTEXT(_L8("Line:\tIncoming Call Notification cancelled"));

	ResetNotifyIncomingCall();

	iPhoneGlobals->iNotificationStore->RemoveNotification(aTsyReqHandle);

	return KErrNone;

	}

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

	{

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

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

	return KErrNone;

	}

TInt CLineHayes::NotifyHookChangeCancel(const TTsyReqHandle aTsyReqHandle)

	{

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

	iPhoneGlobals->iNotificationStore->RemoveNotification(aTsyReqHandle);

	return KErrNone;

	}

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

	{

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

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

	return KErrNone;

	}

TInt CLineHayes::NotifyStatusChangeCancel(const TTsyReqHandle aTsyReqHandle)

	{

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

	iPhoneGlobals->iNotificationStore->RemoveNotification(aTsyReqHandle);

	return KErrNone;

	}

TInt CLineHayes::NotifyCallAdded(const TTsyReqHandle aTsyReqHandle,TName* aName)

	{

	LOGTEXT(_L8("Line:\tCall Added Notification lodged"));

	iPhoneGlobals->iNotificationStore->RegisterNotification(ENewCallAdded,aTsyReqHandle,this,aName);

	return KErrNone;

	}

TInt CLineHayes::NotifyCallAddedCancel(const TTsyReqHandle aTsyReqHandle)

	{

	LOGTEXT(_L8("Line:\tCall Added Notification cancelled"));

	iPhoneGlobals->iNotificationStore->RemoveNotification(aTsyReqHandle);

	return KErrNone;

	}

TInt CLineHayes::NotifyCapsChange(const TTsyReqHandle aTsyReqHandle, RLine::TCaps* /*aCaps*/)

	{

	ReqCompleted(aTsyReqHandle,KErrNotSupported);

	return KErrNone;

	}

TInt CLineHayes::NotifyCapsChangeCancel(const TTsyReqHandle aTsyReqHandle)

	{

	ReqCompleted(aTsyReqHandle,KErrCancel);

	return KErrNone;

	}

CCallEntry* CLineHayes::CheckNewObject(const TDesC& aName) 

//

//	Server should have caught any identical names and treated them as new handles on existing 

//  objects, and not calling OpenNewObjectL() on the TSY. So panic if there is an identical name,

//  unless it is the name of the pre-allocated call owned by the line in which case the server

//  would not have been aware of it.

	{

	CCallEntry* callEntry;

	TDblQueIter<CCallEntry> iter(iCalls);

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

		{

		if(callEntry->iCallHayes->CheckName(aName))

			{

			if (callEntry->iCallHayes->IsOwnedByTSY())

				return callEntry;

			else

				Panic(ECallNameAlreadyExists);

			}

		}

	return NULL;

	}

TInt CLineHayes::GetInfo(const TTsyReqHandle aTsyReqHandle, RLine::TLineInfo* aLineInfo)

	{

	aLineInfo->iHookStatus = RCall::EHookStatusOn;

	aLineInfo->iStatus = RCall::EStatusIdle;

	CCallEntry* callEntry;

	TDblQueIter<CCallEntry> iter(iCalls);

	while (callEntry=iter++, callEntry)

		{

		TCallInfoTSY* infoTSY = callEntry->iCallHayes->CallInfo();

		if (infoTSY->iHookStatus == RCall::EHookStatusOff)

			{

			aLineInfo->iHookStatus = RCall::EHookStatusOff;

			}

		if (callEntry->iCallHayes->GetCoreCallStatus() == iPhoneGlobals->iPhoneStatus.iLineStatus)

			{

			aLineInfo->iStatus = iPhoneGlobals->iPhoneStatus.iLineStatus;

			}

		}

	GetLastCallName(aLineInfo->iNameOfLastCallAdded);

	ReqCompleted(aTsyReqHandle,KErrNone);

	return KErrNone;

	}

TInt CLineHayes::GetStatus(const TTsyReqHandle aTsyReqHandle,RCall::TStatus* aLineStatus)

//

//	This line may not be the one on which a call is being made, so check to see if any of

//  the calls on this line have the same status as the 'global' line status and if so, this

//  can be assumed to be that line

//

	{

	CCallEntry* callEntry;

	TDblQueIter<CCallEntry> iter(iCalls);

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

		{

		if (callEntry->iCallHayes->GetCoreCallStatus() == iPhoneGlobals->iPhoneStatus.iLineStatus)

			{

			*aLineStatus = iPhoneGlobals->iPhoneStatus.iLineStatus;

			ReqCompleted(aTsyReqHandle,KErrNone);

			return KErrNone;

			}

		}

	*aLineStatus = RCall::EStatusIdle;

	ReqCompleted(aTsyReqHandle,KErrNone);

	return KErrNone;

	}

TInt CLineHayes::EnumerateCall(const TTsyReqHandle aTsyReqHandle,TInt* aParams)

//

//	Enumerate calls

//

	{

	LOGTEXT(_L8("Line:\tEnumerate Calls"));

	TInt count=0;

	TDblQueIter<CCallEntry> iter(iCalls);

	while (iter++)

		{

		count++;

		}

	*aParams = count;

	ReqCompleted(aTsyReqHandle,KErrNone);

	return KErrNone;

	}

TInt CLineHayes::GetHookStatus(const TTsyReqHandle aTsyReqHandle,RCall::THookStatus* aHookStatus)

//

//	Hook is considered ON if no calls exist on this line, or if all calls are idle

//	OFF if at least one is not idle. Should not be more than one active call.

//

	{

	LOGTEXT(_L8("Line:\tGet hook status"));

	RCall::THookStatus hookStatus = RCall::EHookStatusOn;

	CCallEntry* callEntry;

	TDblQueIter<CCallEntry> iter(iCalls);

	while (callEntry=iter++, callEntry)

		{

		if (callEntry->iCallHayes->CallInfo()->iHookStatus == RCall::EHookStatusOff)

			{

			hookStatus = RCall::EHookStatusOff;

			break;	// if any calls are active, line hook status is off

			}

		}

	*aHookStatus = hookStatus;

	ReqCompleted(aTsyReqHandle,KErrNone);

	return KErrNone;

	}

void CLineHayes::SetCallsHookStatus(RCall::THookStatus aHookStatus)

//

//	Is it valid to set all calls to a certain hook status at any time?

//

	{

	CCallEntry* callEntry;

	TDblQueIter<CCallEntry> iter(iCalls);

	while (callEntry=iter++, callEntry)

		callEntry->iCallHayes->CallInfo()->iHookStatus = aHookStatus;

	}

TBool CLineHayes::StopMyCallRinging()

	{

	CCallEntry* callEntry;

	TDblQueIter<CCallEntry> iter(iCalls);

	while (callEntry=iter++, callEntry)

		{

		if (callEntry->iCallHayes->CallInfo()->iMobileStatus==RMobileCall::EStatusRinging)

			{

			// EStatusIdle always results in KErrNone return

			(void)callEntry->iCallHayes->ChangeCallStatus(RMobileCall::EStatusIdle);

			return ETrue;

			}

		}

	return EFalse;

	}

void CLineHayes::GetLineStatus(RCall::TStatus& aLineStatus)

	{

	aLineStatus=iPhoneGlobals->iPhoneStatus.iLineStatus;

	}

void CLineHayes::RemoveCall(CCallHayes* aCallHayes)

//

//	When a call closes, it calls this to remove itself from the array

//

	{

	CCallEntry* callEntry;

	TDblQueIter<CCallEntry> iter(iCalls);

	while (callEntry=iter++, callEntry)

		{

		if (callEntry->iCallHayes == aCallHayes)

			{

			callEntry->Deque();

			delete callEntry;	// just deletes list entry, not the call itself

			break;

			}

		}

	}

void CLineHayes::GetLastCallName(TDes& aName) const

	{

	TCallInfoIndex callInfo;

	if (iCalls.IsEmpty())

		{

		aName.Zero();

		return;

		}

	CCallEntry* callEntry = iCalls.Last();

	__ASSERT_ALWAYS(callEntry,Panic(ENewCallDoesNotExist));

	callEntry->iCallHayes->GetCallInfo(&callInfo);

	aName = callInfo.iInfo.iCallName;

	}

void CLineHayes::GetNameOfCallForAnswering(TDes& aName)

	{

	TCallInfoIndex callInfo;

	CCallEntry* callEntry;

	TDblQueIter<CCallEntry> iter(iCalls);

	while (callEntry=iter++, callEntry)

		{

		if (callEntry->iCallHayes->IsForIncomingCall() || callEntry->iCallHayes->IsOwnedByTSY())

			{

			callEntry->iCallHayes->GetCallInfo(&callInfo);

			aName = callInfo.iInfo.iCallName;

			return;

			}

		}

	aName.Zero();

	}

TBool CLineHayes::AnswerIfPossible()

//

//	Finds the call on this line which has been asked to Answer the next incoming call, if it

//	exists, and tells it to answer.

//

	{

	CCallEntry* callEntry;

	TDblQueIter<CCallEntry> iter(iCalls);

	while (callEntry=iter++, callEntry)

		{

		if ((callEntry->iCallHayes->IsForIncomingCall()))

			{

			callEntry->iCallHayes->AnswerImmediately();

			return ETrue;

			}

		}

	return EFalse;

	}

TBool CLineHayes::CheckForOutstandingAnswer()

	{

	CCallEntry* callEntry;

	TDblQueIter<CCallEntry> iter(iCalls);

	while (callEntry=iter++, callEntry)

		{

		if (callEntry->iCallHayes->IsForIncomingCall())

			return ETrue;

		}

	return EFalse;

	}

const CArrayFixFlat<TInt>* CLineHayes::ArrayOfMemberDataSizes(const TInt /*aIpc*/) const

	{

	return iSizeOfMemberData;

	}

void CLineHayes::ResetNotifyIncomingCall()

	{

	iNotifyIncomingCallOutstanding=EFalse;

	}

TBool CLineHayes::IsNotifyIncomingCallOutstanding()

	{

	return iNotifyIncomingCallOutstanding;

	}

//

// Unimplemented Line Request Functions

//

TInt CLineHayes::ExtFunc(const TTsyReqHandle,const TInt, const TDataPackage&)

//

// Extensions aren't supported in this TSY

//

	{

	return KErrNotSupported;

	}

/*

 *  CLineMobile class that implements Multimode ETel Mobile Call requests

 */

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

			: CLineHayes(aIo, aInit, aPhoneGlobals)

	{}

CLineMobile::~CLineMobile()

	{

	}

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

	{

	// ReqModeL is called from the server's CTelObject::ReqAnalyserL

	// in order to check the type of request it has

	CTelObject::TReqMode ret=0;

	switch (aIpc)

		{

//

// No Flow Control NOR Multiple Completion

//

	case EMobileLineGetMobileLineStatus:

		break;

//

// Multiple Completion Services with Immediate Server Repost

// (Usually Notifications)

//

	case EMobileLineNotifyMobileLineStatusChange:

		ret=KReqModeMultipleCompletionEnabled | KReqModeRePostImmediately;

		break;

//

// Not Supported

//

	default:

		ret=CLineHayes::ReqModeL(aIpc);

		break;

		}

	return ret;

	}

TInt CLineMobile::NumberOfSlotsL(const TInt aIpc)

	{

	// NumberOfSlotsL is called by the server when it is registering a new notification

	// It enables the TSY to tell the server how many buffer slots to allocate for

	// "repost immediately" notifications that may trigger before clients collect them

	TInt numberOfSlots=1;

	switch (aIpc)

		{

	case EMobileLineNotifyMobileLineStatusChange:

		LOGTEXT(_L8("CLineMobile: Registered with 5 slots"));

		numberOfSlots=5;

		break;

	default:

		numberOfSlots = CLineBase::NumberOfSlotsL(aIpc);

		break;

		}

	return numberOfSlots;

	}

TInt CLineMobile::ExtFunc(const TTsyReqHandle aTsyReqHandle,const TInt aIpc,

					 	  const TDataPackage& aPackage)

	{

	// ExtFunc is called by the server when it has a "extended", i.e. non-core ETel request 

	// for the TSY to process