/*

* Copyright (c) 2009 Sony Ericsson Mobile Communications AB

* 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:

* Sony Ericsson Mobile Communications AB - initial contribution.

* Nokia Corporation - additional changes.

* 

* Contributors:

* 

* Description:

* Code for CTelephonyFunctions class, used by CTelephony class.

*

*/

/**

 @file

*/

#include <e32def.h>

#include <etel3rdparty.h>

#include "TelephonyFunctions.h"

// Constructors

EXPORT_C CTelephony* CTelephony::NewLC()

/**

Constructs a CTelephony object.

A pointer to this object is left on the CleanupStack.

The returned pointer is typically assigned to a pointer-variable

on the stack.

@return	Pointer to a newly created CTelephony object.

*/

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

EXPORT_C CTelephony* CTelephony::NewL()

/**

Constructs a CTelephony object.

No pointer to this object is left on the CleanupStack.

The returned pointer is typically assigned to a pointer-variable

stored in the Heap.

@return	Pointer to a newly created CTelephony object.

*/

	{

	CTelephony* self=NewLC();

	CleanupStack::Pop();

	return self;

	}

// Destructors

CTelephony::~CTelephony() // virtual, so no export

/**

Destructor

Deletes the underlying CTelephonyFunctions object.

*/

	{

	delete iTelephonyFunctions;

	}

/**

This method is no longer supported.

@return KErrNotSupported

@publishedAll

@deprecated

*/

EXPORT_C TInt CTelephony::FindDeviceStatus(TInt& /*aCallStatus*/)

	{

	return KErrNotSupported;

	}

/**

This method is no longer supported. 

It was used to establish a circuit-switched data call, but support was removed

as functionality was no longer required by licensees. Developers should

consider using GPRS via RConnection and RSocket for data functionality instead.

@return KErrNotSupported

@publishedAll

@deprecated

@see RConnection

@see RSocket

@see RMobilePhone

*/

EXPORT_C TInt CTelephony::EstablishDataCall(TInt& /*aDataChannel*/, const TDesC& /*aDialNumber*/)

	{

	return KErrNotSupported;

	}

/**

This method is no longer supported.

It was used to establish a circuit-switched data call, but support was removed

as functionality was no longer required by licensees. Developers should

consider using GPRS via RConnection and RSocket for data functionality instead.

@publishedAll

@deprecated

@see RConnection

@see RSocket

@see RMobilePhone

*/

EXPORT_C void CTelephony::EstablishDataCall(TRequestStatus& aRequestStatus, TInt& /*aDataChannel*/,

                                            const TDesC& /*aDialNumber*/)

	{

	TRequestStatus* reqStatusPtr = &aRequestStatus;

	User::RequestComplete(reqStatusPtr, KErrNotSupported);

	}

/**

This method is no longer supported.

It was used to terminate a circuit-switched data call, but support was removed

as functionality was no longer required by licensees. Developers should

consider using GPRS via RConnection and RSocket for data functionality instead.

@return KErrNotSupported

@publishedAll

@deprecated

@see RConnection

@see RSocket

@see RMobilePhone

*/

EXPORT_C TInt CTelephony::TerminateDataCall()

	{

	return KErrNotSupported;

	}

/**

This method is no longer supported.

It was used to receive a circuit-switched data call, but support was removed

as functionality was no longer required by licensees. Developers should

consider using GPRS via RConnection and RSocket for data functionality instead.

@return KErrNotSupported

@publishedAll

@deprecated

@see RConnection

@see RSocket

@see RMobilePhone

*/

EXPORT_C TInt CTelephony::ReceiveDataCall(TInt& /*aDataChannel*/)

	{

	return KErrNotSupported;

	}

/**

This method is no longer supported.

It was used to receive a circuit-switched data call, but support was removed

as functionality was no longer required by licensees. Developers should

consider using GPRS via RConnection and RSocket for data functionality instead.

@publishedAll

@deprecated

@see RConnection

@see RSocket

@see RMobilePhone

*/

EXPORT_C void CTelephony::ReceiveDataCall(TRequestStatus& aRequestStatus, TInt& /*aDataChannel*/)

	{

	TRequestStatus* reqStatusPtr = &aRequestStatus;

	User::RequestComplete(reqStatusPtr, KErrNotSupported);

	}

/**

This method is no longer supported.

It was used to cancel an outstanding request to establish a circuit-switched

data call, but support was removed as functionality was no longer required by

licensees. Developers should consider using GPRS via RConnection and RSocket

for data functionality instead.

@publishedAll

@deprecated

@see RConnection

@see RSocket

@see RMobilePhone

*/

EXPORT_C void CTelephony::CancelEstablishDataCall()

	{

	return;

	}

/**

This method is no longer supported.

It was used to cancel an outstanding request to receive a circuit-switched data

call, but support was removed as functionality was no longer required by

licensees. Developers should consider using GPRS via RConnection and RSocket

for data functionality instead.

@publishedAll

@deprecated

@see RConnection

@see RSocket

@see RMobilePhone

*/

EXPORT_C void CTelephony::CancelReceiveDataCall()

	{

	return;

	}

// constructor support

// Not exported, as used only by functions inside this DLL, eg NewLC()

CTelephony::CTelephony()

//

//First-phase constructor

//

//Private function which cannot Leave().

//

	{

	}

// Class member functions

void CTelephony::ConstructL()

//

//Second-phase constructor

//

//Allocates and initialises CTelephony object by constructing a

//CTelephonyFunctions object where the real work is done.

//

	{

	iTelephonyFunctions = CTelephonyFunctions::NewL();

	}

EXPORT_C TInt CTelephony::CancelAsync(TCancellationRequest aCancel) const

/**

Cancels an outstanding asynchronous request.  

The result of the cancellation request will be reflected through the 

request status of the pending request.  A status of KErrCancel denotes 

that the request has been safely cancelled.

@param aCancel Canncellation code of request to be cancelled.

@capability None

*/

	{

	return iTelephonyFunctions->CancelAsync(aCancel);

	}

/////////////////////////////////////////////////

//Notifier related exports

/////////////////////////////////////////////////

EXPORT_C void CTelephony::NotifyChange(TRequestStatus& aReqStatus, const TNotificationEvent& aEvent, TDes8& aDes) const

/**

Registers interest in receiving change notifications for events.

Specify the event that you are interested with the aEvent parameter. 

Each event is associated with a packaged class.  Pass an instance of 

this class to this method.  Then, when the event occurs, information 

relating to the event is written into it.  The description

of CTelephony::TNotificationEvent tells you the information class for 

each event.

This is an asynchronous method. Notification can be cancelled using the

cancellation codes specified in CTelephony::TNotificationEvent. Pass the

appropriate code to CTelephony::CancelAsync() to cancel the notification

request.

@param aReqStatus Returns the result code after the asynchronous call completes.

@param aEvent Event on which change notification is requested. 

@param aDes Packaged information class.  On completion, information 

relating to the event is written into this class.  Until then, this 

class's data is not valid.

@capability Dependent This function depends on the TNotificationEvent value 

passed to it.

*/

	{

	TRequestStatus* reqStatusPtr = &aReqStatus;

	__ASSERT_ALWAYS(aReqStatus != KRequestPending,

		User::Panic(KTelephonyCategory, KTelephonyPanicIllegalReuse) );

	aReqStatus = KRequestPending;

	TInt rc=KErrInUse;

	TRAPD(leaveCode, rc=iTelephonyFunctions->NotifyChangeL(aReqStatus, aEvent, aDes););

	if(leaveCode != KErrNone)

		{

		iTelephonyFunctions->ResetPendingNotifyRequest(aEvent);

		User::RequestComplete(reqStatusPtr, leaveCode);

		}

	else if (rc != KErrNone)

		{

		if(rc != KErrInUse)	//this means request already pending, so do not reset

			{

			iTelephonyFunctions->ResetPendingNotifyRequest(aEvent);

			}

		User::RequestComplete(reqStatusPtr, rc);

		}

	}

/////////////////////////////////////////////////

//Call related exports

/////////////////////////////////////////////////

EXPORT_C CTelephony::TCallParamsV1::TCallParamsV1()

/**

Default constructor.

*/

	{

	iVersionId=KEtelISVV1;

	}

EXPORT_C void CTelephony::DialNewCall(TRequestStatus& aRequestStatus, TDes8& aCallParams, 

							 const CTelephony::TTelNumber& aTelNumber, CTelephony::TCallId& aCallId, const CTelephony::TPhoneLine aLine) const 

/**

Initiates a new call.

The client specifies the telephone number via the aTelNumber argument 

and the desired call parameters via the aCallParams argument. 

This is an asynchronous method. After successful completion of the dial request 

a call identifier is returned back to the client via the aCallId argument.  

The call identifier is needed to hold, resume, swap, and terminate the call.  

It is also needed to monitor the status of the call.

This functionality is not available when the phone is in "flight" mode.

@param aRequestStatus Returns the result code after the asynchronous 

call completes.  Pass CTelephony::CancelAsync() CTelephony::EDialNewCallCancel to cancel.

@param aCallParams The call parameters used by the TSY.  Pass a CTelephony::TCallParamsV1Pckg, a 

packaged CTelephony::TCallParamsV1.

@param aTelNumber  Telephone number to dial.

@param aCallId Upon completion, contains the call identifier. 

@param aLine Line on which call can be made. Currently, only voice calls are supported.

@see AnswerIncomingCall()

@see Hold()

@see Resume()

@see Swap()

@see Hangup()

@see GetCallStatus()

@see GetCallDynamicCaps()

@capability NetworkServices

*/

	{

	TRequestStatus* reqStatusPtr = &aRequestStatus;

	__ASSERT_ALWAYS(aRequestStatus != KRequestPending,

		User::Panic(KTelephonyCategory, KTelephonyPanicIllegalReuse) );

	aRequestStatus = KRequestPending;

	TInt rc=KErrInUse;	

	TRAPD(leaveCode, rc=iTelephonyFunctions->DialNewCallL(aRequestStatus, aCallParams, aTelNumber,aCallId,aLine));

	if(leaveCode != KErrNone)

		{	

		iTelephonyFunctions->SetRequestPending(CTelephonyFunctions::EDialNewCall, EFalse);

		User::RequestComplete(reqStatusPtr, leaveCode);

		}

	else if (rc != KErrNone)

		{

		if(rc != KErrInUse)	//this means request already pending, so do not reset

			{

			iTelephonyFunctions->SetRequestPending(CTelephonyFunctions::EDialNewCall, EFalse);

			}

		User::RequestComplete(reqStatusPtr, rc);

		}

	}

EXPORT_C void CTelephony::Hold(TRequestStatus& aRequestStatus, const CTelephony::TCallId& aCallId) const

/**

Places a call on hold. This is only for calls you dialled or answered with CTelephony. 

The call's dynamic capabilities must allow the Hold operation for 

this call to have successful completion of this request; see CTelephony::GetCallDynamicCaps().

This is an asynchronous method. Upon successful completion of Hold, line and call status might be affected by this operation. 

Hold is only available for the voice line.

This functionality is not available when the phone is in "flight" mode.

@param aRequestStatus Returns the result code after the asynchronous 

call completes. Pass CTelephony::CancelAsync() CTelephony::EHoldCancel to cancel.

@param aCallId Call ID, as returned by CTelephony::DialNewCall() or CTelephony::AnswerIncomingCall().

@see AnswerIncomingCall()

@see DialNewCall()

@see Resume()

@see Swap()

@see Hangup()

@see GetCallStatus()

@see GetCallDynamicCaps()

@capability NetworkServices

*/

	{

	TRequestStatus* reqStatusPtr = &aRequestStatus;

	__ASSERT_ALWAYS(aRequestStatus != KRequestPending,

		User::Panic(KTelephonyCategory, KTelephonyPanicIllegalReuse) );

	aRequestStatus = KRequestPending;

	TInt rc=KErrInUse;	

	TRAPD(leaveCode, rc=iTelephonyFunctions->HoldL(aRequestStatus, aCallId));

	if(leaveCode != KErrNone)

		{

		iTelephonyFunctions->SetRequestPending(CTelephonyFunctions::EHold, EFalse);	

		User::RequestComplete(reqStatusPtr, leaveCode);

		}

	else if (rc != KErrNone)

		{

		if(rc != KErrInUse)	//this means request already pending, so do not reset

			{

			iTelephonyFunctions->SetRequestPending(CTelephonyFunctions::EHold, EFalse);

			}

		User::RequestComplete(reqStatusPtr, rc);

		}

	}

EXPORT_C void CTelephony::Resume(TRequestStatus& aRequestStatus, const CTelephony::TCallId& aCallId) const

/**

Resumes a held call. This is only for calls you dialled or answered with CTelephony.  

The client specifies the call ID via the aCallId argument. 

The call's dynamic capabilities must allow the Resume operation for this 

call to have successful completion of this request; see CTelephony::GetCallDynamicCaps().

This is an asynchronous method. Upon successful completion of Resume, line and 

call status might be affected by this operation. 

Resume is only available for the voice line.

This functionality is not available when the phone is in "flight" mode.

@param aRequestStatus Returns the result code after the asynchronous 

call completes.  Pass CTelephony::CancelAsync() CTelephony::EResumeCancel to cancel.

@param aCallId Call ID, as returned by CTelephony::DialNewCall() or CTelephony::AnswerIncomingCall().

@see AnswerIncomingCall()

@see DialNewCall()

@see Hold()

@see Swap()

@see Hangup()

@see GetCallStatus()

@see GetCallDynamicCaps()

@capability NetworkServices

*/

	{

	TRequestStatus* reqStatusPtr = &aRequestStatus;

	__ASSERT_ALWAYS(aRequestStatus != KRequestPending,

		User::Panic(KTelephonyCategory, KTelephonyPanicIllegalReuse) );

	aRequestStatus = KRequestPending;

	TInt rc=KErrInUse;	

	TRAPD(leaveCode, rc=iTelephonyFunctions->ResumeL(aRequestStatus, aCallId));

	if(leaveCode != KErrNone)

		{	

		iTelephonyFunctions->SetRequestPending(CTelephonyFunctions::EResume, EFalse);

		User::RequestComplete(reqStatusPtr, leaveCode);

		}

	else if (rc != KErrNone)

		{

		if(rc != KErrInUse)	//this means request already pending, so do not reset

			{

			iTelephonyFunctions->SetRequestPending(CTelephonyFunctions::EResume, EFalse);

			}

		User::RequestComplete(reqStatusPtr, rc);

		}

	}

EXPORT_C void CTelephony::Swap(TRequestStatus& aRequestStatus, const CTelephony::TCallId& aCallId1, const 

					  CTelephony::TCallId& aCallId2) const

/**

Swaps calls. This is only for calls you dialled or answered with CTelephony. 

Swap is possible only if both calls are owned by this ISV application. 

The client specifies the call ids via the aCallId1 and aCallId2 arguments. 

This is an asynchronous method.

The calls' dynamic capabilities must allow the Swap operation for this call to 

have successful completion of this request; see CTelephony::GetCallDynamicCaps().

Swap is only available for the voice line.

This functionality is not available when the phone is in "flight" mode.

@param aRequestStatus Returns the result code after the asynchronous 

call completes. Pass CTelephony::CancelAsync() CTelephony::ESwapCancel to cancel.

@param aCallId1 ID of a call, as returned by CTelephony::DialNewCall() or CTelephony::AnswerIncomingCall().