/*

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

* TelephonyActPhone.cpp

* Code for TelephonyActPhone class, used by CTelephonyFunctions class.

*

*/

/**

 @file

*/

#include "TelephonyFunctions.h"

#include "TelephonyActCall.h"

CDialNewCallAct* CDialNewCallAct::NewL(CTelephonyFunctions* aTelephonyFunctions)

/**

Public constructor which can Leave().

@param	aTelephonyFunctions Object that constructs us.

@leave	Leaves if no memory.

*/

	{

	CDialNewCallAct* self = new(ELeave) CDialNewCallAct(aTelephonyFunctions);

	CActiveScheduler::Add(self);

	return self;

	}

CDialNewCallAct::~CDialNewCallAct()

/**

Destructor

*/

	{

	Cancel();

	Complete();

	}

void CDialNewCallAct::DialNewCall(TDes8& aCallParams,const CTelephony::TTelNumber& aTelNumber, CTelephony::TCallId& aCallId,

								  CTelephony::TCallId& aTempCallId)

/**

Issue dial request

*/

	{

	iISVcallParams = reinterpret_cast<CTelephony::TCallParamsV1*> ( const_cast<TUint8*> (aCallParams.Ptr()) );

	iCallId=&aCallId;

	iTempCallId=aTempCallId;

	switch(iISVcallParams->iIdRestrict)

		{

		case CTelephony::ESendMyId:

			iMMcallParams.iIdRestrict = RMobileCall::ESendMyId;

			break;

		case CTelephony::EDontSendMyId:

			iMMcallParams.iIdRestrict = RMobileCall::EDontSendMyId;

			break;

		case CTelephony::EIdRestrictDefault:

		default:

			iMMcallParams.iIdRestrict = RMobileCall::EIdRestrictDefault;

			break;

		}

	iTelephonyFunctions->Call(iTempCallId)->DialISV(iStatus, iMMCallParamsPckg, aTelNumber);

	SetActive();

	}

void CDialNewCallAct::Complete()

/**

Service Completed request.

@leave	Leaves if System error.

*/

	{

	if(iTelephonyFunctions->IsRequestPending(CTelephonyFunctions::EDialNewCall))

		{

		if(iStatus == KErrNone)

			{

			*iCallId=iTempCallId;

			}

		else if(iStatus != KRequestPending &&	iStatus != KErrNone)

	  		{

	  		iTelephonyFunctions->CloseAndReset(iTempCallId);

	  		}

	  	iTelephonyFunctions->CompleteRequest(CTelephonyFunctions::EDialNewCall, iStatus.Int());

		}

	}

TInt CDialNewCallAct::RunError(TInt aLeaveCode)

/**

Handle any Leave() from inside RunL().

@param	aLeaveCode	passed in if RunL Leaves.

@return	KErrNone.

*/

	{

	iTelephonyFunctions->CompleteRequest(CTelephonyFunctions::EDialNewCall, aLeaveCode);

	return KErrNone;

	}

void CDialNewCallAct::DoCancel()

/**

Cancel request.

Async request to dial is cancelled.

*/

	{

	if(iTelephonyFunctions->Call(iTempCallId))

		{

		iTelephonyFunctions->Call(iTempCallId)->CancelAsyncRequest(EMobileCallDialISV);

		}

	}

CDialNewCallAct::CDialNewCallAct(CTelephonyFunctions* aTelephonyFunctions)

: CAsyncRequestBaseAct(),

  iTelephonyFunctions(aTelephonyFunctions),

  iMMCallParamsPckg(iMMcallParams)

/**

First-phase constructor which cannot Leave().

@param	aTelephonyFunctions Object that constructs us.

*/

	{

	}

CHoldAct* CHoldAct::NewL(CTelephonyFunctions* aTelephonyFunctions)

/**

Public constructor which can Leave().

@param	aTelephonyFunctions Object that constructs us.

@leave	Leaves if no memory.

*/

	{

	CHoldAct* self = new(ELeave) CHoldAct(aTelephonyFunctions);

	CActiveScheduler::Add(self);

	return self;

	}

CHoldAct::~CHoldAct()

/**

Destructor

*/

	{

	Cancel();

	Complete();

	}

void CHoldAct::Hold(const CTelephony::TCallId& aCallId)

/**

Issue Request

*/

	{

	iCallId = aCallId;

	iTelephonyFunctions->Call(aCallId)->Hold(iStatus);

	SetActive();

	}

void CHoldAct::Complete()

/**

Service Completed request.

@leave	Leaves if System error.

*/

	{

	iTelephonyFunctions->CompleteRequest(CTelephonyFunctions::EHold, iStatus.Int());

	}

TInt CHoldAct::RunError(TInt aLeaveCode)

/**

Handle any Leave() from inside RunL().

@param	aLeaveCode	passed in if RunL Leaves.

@return	KErrNone.

*/

	{

	iTelephonyFunctions->CompleteRequest(CTelephonyFunctions::EHold, aLeaveCode);

	return KErrNone;

	}

void CHoldAct::DoCancel()

/**

Cancel request.

Async request to dial is cancelled.

*/

	{

	if(iTelephonyFunctions->Call(iCallId))

		{

		iTelephonyFunctions->Call(iCallId)->CancelAsyncRequest(EMobileCallHold);

		}

	}

CHoldAct::CHoldAct(CTelephonyFunctions* aTelephonyFunctions)

: CAsyncRequestBaseAct(),

  iTelephonyFunctions(aTelephonyFunctions)

/**

First-phase constructor which cannot Leave().

@param	aTelephonyFunctions Object that constructs us.

*/

	{

	}

CResumeAct* CResumeAct::NewL(CTelephonyFunctions* aTelephonyFunctions)

/**

Public constructor which can Leave().

@param	aTelephonyFunctions Object that constructs us.

@leave	Leaves if no memory.

*/

	{

	CResumeAct* self = new(ELeave) CResumeAct(aTelephonyFunctions);

	CActiveScheduler::Add(self);

	return self;

	}

CResumeAct::~CResumeAct()

/**

Destructor

*/

	{

	Cancel();

	Complete();

	}

void CResumeAct::Resume(const CTelephony::TCallId& aCallId)

/**

Issue Request

*/

	{

	iCallId = aCallId;

	iTelephonyFunctions->Call(aCallId)->Resume(iStatus);

	SetActive();

	}

void CResumeAct::Complete()

/**

Service Completed request.

*/

	{

	iTelephonyFunctions->CompleteRequest(CTelephonyFunctions::EResume, iStatus.Int());

	}

TInt CResumeAct::RunError(TInt aLeaveCode)

/**

Handle any Leave() from inside RunL().

@param	aLeaveCode	passed in if RunL Leaves.

@return	KErrNone.

*/

	{

	iTelephonyFunctions->CompleteRequest(CTelephonyFunctions::EResume, aLeaveCode);

	return KErrNone;

	}

void CResumeAct::DoCancel()

/**

Cancel request.

Async request to dial is cancelled.

*/

	{

	if(iTelephonyFunctions->Call(iCallId))

		{

		iTelephonyFunctions->Call(iCallId)->CancelAsyncRequest(EMobileCallResume);

		}

	}

CResumeAct::CResumeAct(CTelephonyFunctions* aTelephonyFunctions)

: CAsyncRequestBaseAct(),

  iTelephonyFunctions(aTelephonyFunctions)

/**

First-phase constructor which cannot Leave().

@param	aTelephonyFunctions Object that constructs us.

*/

	{

	}

CSwapAct* CSwapAct::NewL(CTelephonyFunctions* aTelephonyFunctions)

/**

Public constructor which can Leave().

@param	aTelephonyFunctions Object that constructs us.

@leave	Leaves if no memory.

*/

	{

	CSwapAct* self = new(ELeave) CSwapAct(aTelephonyFunctions);

	CActiveScheduler::Add(self);

	return self;

	}

CSwapAct::~CSwapAct()

/**

Destructor

*/

	{

	Cancel();

	Complete();

	}

void CSwapAct::Swap(const CTelephony::TCallId& aCallId)

/**

Issue Request

*/

	{

	iCallId = aCallId;

	iTelephonyFunctions->Call(aCallId)->Swap(iStatus);

	SetActive();

	}

void CSwapAct::Complete()

/**

Service Completed request.

*/

	{

	iTelephonyFunctions->CompleteRequest(CTelephonyFunctions::ESwap, iStatus.Int());

	}

TInt CSwapAct::RunError(TInt aLeaveCode)

/**

Handle any Leave() from inside RunL().

@param	aLeaveCode	passed in if RunL Leaves.

@return	KErrNone.

*/

	{

	iTelephonyFunctions->CompleteRequest(CTelephonyFunctions::ESwap, aLeaveCode);

	return KErrNone;

	}

void CSwapAct::DoCancel()

/**

Cancel request.

Async request to dial is cancelled.

*/

	{

	if(iTelephonyFunctions->Call(iCallId))

		{

		iTelephonyFunctions->Call(iCallId)->CancelAsyncRequest(EMobileCallSwap);

		}

	}

CSwapAct::CSwapAct(CTelephonyFunctions* aTelephonyFunctions)

: CAsyncRequestBaseAct(),

  iTelephonyFunctions(aTelephonyFunctions)

/**

First-phase constructor which cannot Leave().

@param	aTelephonyFunctions Object that constructs us.

*/

	{

	}

CHangupAct* CHangupAct::NewL(CTelephonyFunctions* aTelephonyFunctions)

/**

Public constructor which can Leave().

@param	aTelephonyFunctions Object that constructs us.

@leave	Leaves if no memory.

*/

	{

	CHangupAct* self = new(ELeave) CHangupAct(aTelephonyFunctions);

	CActiveScheduler::Add(self);

	return self;

	}

CHangupAct::~CHangupAct()

/**

Destructor

*/

	{

	Cancel();

	Complete();

	}

void CHangupAct::Hangup(const CTelephony::TCallId& aCallId)

/**

Issue Request

*/

	{

	iCallId = aCallId;

	iTelephonyFunctions->Call(aCallId)->HangUp(iStatus);

	SetActive();

	}

void CHangupAct::Complete()

/**

Service Completed request.

*/

	{

	if(iTelephonyFunctions->IsRequestPending(CTelephonyFunctions::EHangup))

		{

		if(iStatus == KErrNone)	//close the call handle if hangup was successful

	  		{

	  		//close and reset call handle

	  		iTelephonyFunctions->CloseAndReset(iCallId);

	  		}

	  	iTelephonyFunctions->CompleteRequest(CTelephonyFunctions::EHangup, iStatus.Int());

		}

	}

TInt CHangupAct::RunError(TInt aLeaveCode)

/**

Handle any Leave() from inside RunL().

@param	aLeaveCode	passed in if RunL Leaves.

@return	KErrNone.

*/

	{

	iTelephonyFunctions->CompleteRequest(CTelephonyFunctions::EHangup, aLeaveCode);

	return KErrNone;

	}

void CHangupAct::DoCancel()

/**

Cancel request.

Async request to dial is cancelled.

*/

	{

	if(iTelephonyFunctions->Call(iCallId))

		{

		iTelephonyFunctions->Call(iCallId)->CancelAsyncRequest(EEtelCallHangUp);

		}

	}

CHangupAct::CHangupAct(CTelephonyFunctions* aTelephonyFunctions)

: CAsyncRequestBaseAct(),

  iTelephonyFunctions(aTelephonyFunctions)

/**

First-phase constructor which cannot Leave().

@param	aTelephonyFunctions Object that constructs us.

*/

	{

	}

/**

Public constructor which can Leave().

@param	aTelephonyFunctions Object that constructs this object.

@param  aIncomingCallNameSubject Reference to an active object owned by iTelephonyFunctions. Used to retrieve the call name of the new incoming call.

@param  aCallPool Reference to the call pool array owned by aTelephonyFunctions

@param  aCallPoolStatus Reference to the call pool status array owned by aTelephonyFunction

@leave	Leaves if no memory.

@return A pointer to the created CAnswerIncomingCallAct object.

*/

CAnswerIncomingCallAct* CAnswerIncomingCallAct::NewL(CTelephonyFunctions* aTelephonyFunctions, MIncomingCallNameSubject& aIncomingCallNameSubject, RArray<RMobileCall>& aCallPool, RArray<CTelephonyFunctions::TCallPoolOperation>& aCallPoolStatus)

	{

	CAnswerIncomingCallAct* self = new(ELeave) CAnswerIncomingCallAct(aTelephonyFunctions, aIncomingCallNameSubject, aCallPool, aCallPoolStatus);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

/**

Second phase constructor.

*/

void CAnswerIncomingCallAct::ConstructL()

	{

	// Create timer for use later if needed.

	User::LeaveIfError(iTimer.CreateLocal());

	// Register interest in receiving notification when a

	// new incoming call is received.

	iIncomingCallNameSubject.RegisterObserver(this);

	CActiveScheduler::Add(this);

	}

/**

Default destructor.

*/

CAnswerIncomingCallAct::~CAnswerIncomingCallAct()

	{

	iIncomingCallNameSubject.DeregisterObserver(this);

	Cancel();

	Complete();

	iTimer.Close();

	}

/**

Issue Request.

This AO starts off in the EAnswerIncomingCallStateIdle state.

In order to answer the incoming call, the line must be ringing and

the CNotifyIncomingCallAct AO must have completed. When this

function is called, it checks if CNotifyIncomingCallAct

has a valid call name available. This means that the notify incoming

call event has completed and the call object has been created.

When this happens, the call can be answered. This AO then moves into

the EAnswerIncomingCallStateAnswering state and proceeds to answer

the call. If CNotifyIncomingCallAct does not have a valid

call name available, then there is no guarantee that the call object

exists and hence the call cannot be answered yet. If this happens,

this AO will move into the EAnswerIncomingCallStateWaiting

state and will wait for up to 1 second for CNotifyIncomingCallAct

AO to complete. If it does complete during or when this one second