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

// This file contains the implementation for the functionality common to all 

// the specific line classes, such as CSimVoiceLine and CSimDataline.

// 

//

/**

 @file

*/

#include <testconfigfileparser.h>

#include "CSimLine.h"

#include "CSimPhone.h"

#include "CSimCall.h"

#include "Simlog.h"

#include "CSimPubSub.h"

void CSimLine::CloseLine(TAny* aObj)

/**

*	Utility func for cleanup stack

*

* @param aObj a pointer to the CObject to close

*/

	{

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

	}

CSimLine::CSimLine(CSimPhone* aPhone)

			:iPhone(aPhone), iState(RMobileCall::EStatusIdle), 

			iHookState(ConvertStateToHook(iState))

	{

	iNameOfLastCallAdded.Zero();

	iNotifyStatusChange.iNotifyPending = EFalse;

	iNotifyMobileStatusChange.iNotifyPending = EFalse;

	}

void CSimLine::ConstructL(const TName& aName)

/**

* Second phase of two phase constructor.

* Creates the System Agent object for incoming call notification and other notifications.

*

* @param aName name of the Line to be created.

*/

	{

	LOGLINE2(">>CSimLine::ConstructL [aLineName=%S]", &aName);

	iLineName = aName;

	iSimPubSubIC = CSimPubSub::NewL(this,iICProperty);

	iSimPubSubIC->Start();

	iSimPubSubRH = CSimPubSub::NewL(this,iRHProperty);

	iSimPubSubRH->Start();

	iNotifyIncomingCallPause=this->CfgFile()->ItemValue(KNotifyIncomingCallPauseDuration,KDefaultNotifyIncomingCallPauseDuration);

	iTimer = CSimTimer::NewL(iPhone);

		LOGLINE1("<<CSimLine::ConstructL");

}

CSimLine::~CSimLine()

/**

*	Standard destructor.

*/

	{

	delete iSimPubSubIC;

	delete iSimPubSubRH;

	iTimer->Cancel();

	delete iTimer;

	}

void CSimLine::UpdatePhoneNotifiers(CSimCall* aCall,TUint /*aStatus*/)

	{

		TInt count=	iCalls->Count();

		TInt i=0;

		while(i<count)

		{

 		if(iCalls->At(i) != aCall && (iCalls->At(i)->iState == RMobileCall::EStatusHold || iCalls->At(i)->iState == RMobileCall::EStatusConnected))

			iCalls->At(i)->UpdateNotifiers();

		i++;

		}	

	}

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

/**

* This function returns the Request Mode for the request with the passed IPC value.

* The ETel Server provides a function for returning the standard request modes for 

* the Core API requests.

* Multimode API requests mode are handled here.

*

* @param aIpc the IPc number representing the client request

* @return CTelObject::TReqMode the request mode to be used for this IPc number

* @leave Leaves if the IPc number is not found

*/

	{

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

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

	CTelObject::TReqMode reqMode=0;

	switch (aIpc)

		{

//

// No Flow Control NOR Multiple Completion

//

	case EMobileLineGetMobileLineStatus:

		break;

//

// Multiple Completion Services with Immediate Server Repost

// (Usually Notifications)

//

	case EMobileLineNotifyMobileLineStatusChange:

		reqMode=KReqModeMultipleCompletionEnabled | KReqModeRePostImmediately;

		break;

//

// Must be a core API request so get request mode from Etel

//

	default:

		reqMode=CLineBase::ReqModeL(aIpc);

		break;

		}

	return reqMode;

	}

TInt CSimLine::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

*

* @param aIpc the IPc number representing the client request

* @return TInt the number of slots required

* @leave Leaves if the IPc number is not found

*/

	{

	switch (aIpc)

		{

	case EMobileLineNotifyMobileLineStatusChange:

		LOGLINE1("CLineMobile: Registered with the default number of slots");

		return KDefaultNumberOfSlots;

	default:

		LOGLINE1("CSimLine::NumberOfSlotsL: No match for IPC, defering to base function");

		break;

		}

	return CLineBase::NumberOfSlotsL(aIpc);

	}

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

/**

* The ETel Server calls this function when the first client makes a notification request.

* If supported by the underlying protocol controlling the signalling stack, 

* this can be used to start requesting updates for the relevant service.

*/

	{

	return KErrNone;

	}

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

/**

* The ETel Server calls this function when the last client that had previously

* made a notification request closes its ETel Server handle.  If supported by

* the underlying protocol controlling the	signalling stack, this can be used

* to stop requesting updates for the relevant service.

*/

	{

	return KErrNone;

	}

void CSimLine::Init()

/**

*	This function can be used to perform any necessary synchronous initialisation.

*/

	{}

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

/**

* Register a client's interest in an incoming call notification.

* Core ETel API Request.

*

* @param aTsyReqHandle Tsy Request handle for the client request

* @param aName pointer to the name of the call

* @return KErrNone

*/

	{

	LOGLINE1(">>CSimLine::NotifyIncomingCall");

	iNotifyIncomingCall.iNotifyPending=ETrue;

	iNotifyIncomingCall.iNotifyHandle=aTsyReqHandle;

	iNotifyIncomingCall.iNotifyData=(TAny*)aName;

	LOGLINE1("<<CSimLine::NotifyIncomingCall");

	return KErrNone;

	}

TInt CSimLine::NotifyIncomingCallCancel(const TTsyReqHandle /*aTsyReqHandle*/)

/**

* Cancels a client's interest in an incoming call.

* Core ETel API Request.

*

* @param aTsyReqHandle Tsy Request handle for the client cancel request

* @return KErrNone

*/

	{

	LOGLINE1(">>CSimLine::NotifyIncomingCallCancel");

	if(iNotifyIncomingCall.iNotifyPending)

		{

		iTimer->Cancel();

		iNotifyIncomingCall.iNotifyPending=EFalse;

		ReqCompleted(iNotifyIncomingCall.iNotifyHandle, KErrCancel);

		}

	LOGLINE1("<<CSimLine::NotifyIncomingCallCancel");

	return KErrNone;

	}

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

/**

* Record a client's interst in being notified when the line hook changes state.

* Core ETel API Request.

*

* @param aTsyReqHandle Tsy Request handle for the client request

* @param aHookStatus pointer to the line hook

* @return KErrNone

*/

	{

	LOGLINE1(">>CSimLine::NotifyHookChange");

	iNotifyHookChange.iNotifyPending=ETrue;

	iNotifyHookChange.iNotifyHandle=aTsyReqHandle;

	iNotifyHookChange.iNotifyData=(TAny*)aHookStatus;

	LOGLINE1("<<CSimLine::NotifyHookChange");

	return KErrNone;

	}

TInt CSimLine::NotifyHookChangeCancel(const TTsyReqHandle /*aTsyReqHandle*/)

/**

* Cancel a client's interest in being notified when the line hook changes state.

* Core ETel API Request.

*

* @param aTsyReqHandle Tsy Request handle for the client cancel request

* @return KErrNone

*/

	{

	LOGLINE1(">>CSimLine::NotifyHookChangeCancel");

	if(iNotifyHookChange.iNotifyPending)

		{

		iNotifyHookChange.iNotifyPending=EFalse;

		ReqCompleted(iNotifyHookChange.iNotifyHandle,KErrCancel);

		}

	LOGLINE1("<<CSimLine::NotifyHookChangeCancel");

	return KErrNone;

	}

TInt CSimLine::NotifyMobileLineStatusChange(const TTsyReqHandle aTsyReqHandle, RMobileCall::TMobileCallStatus* aStatus)

/**

* Record a client's interst in being notified when the line changes state. (Multimode)

* MM ETel API Request.

*

* @param aTsyReqHandle Tsy Request handle for the client request

* @param aStatus pointer to the line status

* @return KErrNone

*/

	{

	LOGLINE1(">>CSimLine::NotifyMobileLineStatusChange");

	iNotifyMobileStatusChange.iNotifyPending=ETrue;

	iNotifyMobileStatusChange.iNotifyHandle=aTsyReqHandle;

	iNotifyMobileStatusChange.iNotifyData=aStatus;

	LOGLINE1("<<CSimLine::NotifyMobileLineStatusChange");

	return KErrNone;

	}

TInt CSimLine::NotifyMobileLineStatusChangeCancel(const TTsyReqHandle /*aTsyReqHandle*/)

/**

* Cancel a client's interest in being notified when the line changes state.(Multimode Request)

* MM ETel API Request.

* 

* @param aTsyReqHandle Tsy Request handle for the client cancel request

* @return KErrNone

*/

	{

	LOGLINE1(">>CSimLine::NotifyMobileLineStatusChangeCancel");

	if(iNotifyMobileStatusChange.iNotifyPending)

		{

		iNotifyMobileStatusChange.iNotifyPending=EFalse;

		ReqCompleted(iNotifyMobileStatusChange.iNotifyHandle,KErrCancel);

		}

	LOGLINE1("<<CSimLine::NotifyMobileLineStatusChangeCancel");

	return KErrNone;

	}

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

/**

* Record a client's interst in being notified when the line changes state. (Core)

* Core ETel API Request.

*

* @param aTsyReqHandle Tsy Request handle for the client request

* @param aStatus pointer to the line status

* @return KErrNone

*/

	{

	LOGLINE1(">>CSimLine::NotifyStatusChange");

	iNotifyStatusChange.iNotifyPending=ETrue;

	iNotifyStatusChange.iNotifyHandle=aTsyReqHandle;

	iNotifyStatusChange.iNotifyData=aStatus;

	LOGLINE1("<<CSimLine::NotifyStatusChange");

	return KErrNone;

	}

TInt CSimLine::NotifyStatusChangeCancel(const TTsyReqHandle /*aTsyReqHandle*/)

/**

* Cancel a client's interest in being notified when the line changes state.(Multimode Request)

* Core ETel API Request.

* 

* @param aTsyReqHandle Tsy Request handle for the client cancel request

* @return KErrNone

*/

	{

	LOGLINE1(">>CSimLine::NotifyStatusChangeCancel");

	if(iNotifyStatusChange.iNotifyPending)

		{

		iNotifyStatusChange.iNotifyPending=EFalse;

		ReqCompleted(iNotifyStatusChange.iNotifyHandle,KErrCancel);

		}

	LOGLINE1("<<CSimLine::NotifyStatusChangeCancel");

	return KErrNone;

	}

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

/**

* Record a client's interest in being notified when a new call is added.

* Core ETel API Request.

*

* @param aTsyReqHandle Tsy Request handle for the client request

* @param aName pointer to the name of the call

* @return KErrNone

*/

	{

	LOGLINE1(">>CSimLine::NotifyCallAdded");

	iNotifyCallAdded.iNotifyPending=ETrue;

	iNotifyCallAdded.iNotifyHandle=aTsyReqHandle;

	iNotifyCallAdded.iNotifyData=(TAny*)aName;

	LOGLINE1("<<CSimLine::NotifyCallAdded");

	return KErrNone;

	}

TInt CSimLine::NotifyCallAddedCancel(const TTsyReqHandle /*aTsyReqHandle*/)

/**

* Cancel a client's interest in being notified when a new call is added.

* Core ETel API Request.

*

* @param aTsyReqHandle Tsy Request handle for the client cancel request

* @return KErrNone

*/

	{

	LOGLINE1(">>CSimLine::NotifyCallAddedCancel");

	if(iNotifyCallAdded.iNotifyPending)

		{

		iNotifyCallAdded.iNotifyPending=EFalse;

		ReqCompleted(iNotifyCallAdded.iNotifyHandle,KErrCancel);

		}

	LOGLINE1("<<CSimLine::NotifyCallAddedCancel");

	return KErrNone;

	}

void CSimLine::HandleNewCallAddedNotification(const TDesC& aNewName)

/**

* Process a potential "New Call Added Notification" completion.

*/

	{

	LOGLINE1(">>CSimLine::HandleNewCallAddedNotification");

	iNameOfLastCallAdded.Copy(aNewName);

	if(iNotifyCallAdded.iNotifyPending)

		{

		iNotifyCallAdded.iNotifyPending=EFalse;

		((TName*)iNotifyCallAdded.iNotifyData)->Copy(aNewName);

		ReqCompleted(iNotifyCallAdded.iNotifyHandle,KErrNone);

		}

	LOGLINE1("<<CSimLine::HandleNewCallAddedNotification");

	}

TInt CSimLine::GetCaps(const TTsyReqHandle aTsyReqHandle, RLine::TCaps* aCaps)

/**

 * Retrieve the current line capabilities.

 * Core ETel API Request.

 *

 * @param aTsyReqHandle		TSY request handle associated with this request.

 * @param aCaps				Point to capability structure that will be populated with the caps.

 * @return TInt				Standard return value.

 */

	{

	aCaps->iFlags=iCaps;

	ReqCompleted(aTsyReqHandle,KErrNone);

	return KErrNone;

	}

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

/**

* Register a client's interest in being notified when the line caps change.

* Core ETel API Request.

*

* @param aTsyReqHandle	The TSY handle associated with this request.

* @param aCaps			The capability structure that will be populated with the new capability

*						information.

* @return TInt			Standard error code.

*/

	{

	__ASSERT_ALWAYS(!iNotifyCapsChange.iNotifyPending,SimPanic(ENotificationReqAlreadyOutstanding));

	iNotifyCapsChange.iNotifyPending=ETrue;

	iNotifyCapsChange.iNotifyHandle=aTsyReqHandle;

	iNotifyCapsChange.iNotifyData=aCaps;

	return KErrNone;

	}

TInt CSimLine::NotifyCapsChangeCancel(const TTsyReqHandle /*aTsyReqHandle*/)

/**

* Cancel a client's interest in being notified when the call capabilities change.

* Core ETel API Request.

*/

	{

	if(iNotifyCapsChange.iNotifyPending)

		{

		iNotifyCapsChange.iNotifyPending=EFalse;

		ReqCompleted(iNotifyCapsChange.iNotifyHandle,KErrCancel);

		}

	return KErrNone;

	}

TInt CSimLine::GetInfo(const TTsyReqHandle aTsyReqHandle, RMobileLine::TLineInfo* aLineInfo)

/**

* Retrieve the Line Information

* Core ETel API Request.

*

* @param aTsyReqHandle

* @param aLineInfo pointer to the line information to be returned to client

* @return KErrNone

*/

	{

	LOGLINE1(">>CSimLine::GetInfo");

	aLineInfo->iHookStatus=iHookState;

	aLineInfo->iStatus=(RCall::TStatus)iState;

	aLineInfo->iNameOfLastCallAdded.Copy(iNameOfLastCallAdded);

	if(iAnswerNextIncomingCall)

		aLineInfo->iNameOfCallForAnswering.Copy(iAnswerNextIncomingCall->iName);

	else

		aLineInfo->iNameOfCallForAnswering.Zero();

	ReqCompleted(aTsyReqHandle,KErrNone);

	LOGLINE1("<<CSimLine::GetInfo");

	return KErrNone;

	}

RCall::TStatus CSimLine::GetCoreLineStatus()

/**

* Converts Multimode call status (RMobileCall::TMobileCallStatus) to 

*          Core call Status (RCall::TStatus)

*

* @return RCall::TStatus The core call status

*/

	{

// All status enums with values of Disconnecting and below are identical in

// ETelMM and Core, so the mapping function is simple.

	RCall::TStatus coreStatus;

	if (iState <= RMobileCall::EStatusDisconnecting)

		coreStatus = (RCall::TStatus)iState;

	else

		switch (iState)

		{

		case RMobileCall::EStatusReconnectPending:

		case RMobileCall::EStatusHold:

			coreStatus = RCall::EStatusConnected;

			break;

		case RMobileCall::EStatusWaitingAlternatingCallSwitch:

			coreStatus = RCall::EStatusIdle;

			break;

		default:

			coreStatus = RCall::EStatusUnknown;

			break;

		}

	return coreStatus;

	}