diff -r 000000000000 -r 3553901f7fa8 telephonyutils/etel3rdpartyapi/src/TelephonyFunctions.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/telephonyutils/etel3rdpartyapi/src/TelephonyFunctions.cpp	Tue Feb 02 01:41:59 2010 +0200
@@ -0,0 +1,1515 @@
+/*
+* 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 "TelephonyFunctions.h"
+#include "TelephonyActPhone.h"
+#include "TelephonyActSupplServices.h"
+#include "TelephonyActLine.h"
+#include "TelephonyActCall.h"
+#include "TelephonyActNetwork.h"
+
+#include <commsdattypesv1_1.h>
+#include <cdblen.h>
+#include <commsdat_partner.h>
+using namespace CommsDat;
+
+// construct/destruct
+
+CTelephonyFunctions* CTelephonyFunctions::NewLC()
+/**
+Constructs a CTelephonyFunctions object.
+
+A pointer to this object is left on the CleanupStack.
+
+@leave	Leaves if no memory, or underlying Etel DLL returns error.
+@return	Pointer to a newly created CTelephonyFunctions object connected to an RTelServer.
+*/
+	{
+	CTelephonyFunctions* self=new (ELeave) CTelephonyFunctions();
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	return self;
+	}
+
+CTelephonyFunctions* CTelephonyFunctions::NewL()
+/**
+Constructs a CTelephonyFunctions object.
+
+@leave	Leaves if no memory, or underlying Etel DLL returns error.
+@return	pointer to a newly created CTelephonyFunctions object connected to an RTelServer.
+*/
+	{
+	CTelephonyFunctions* self=NewLC();
+	CleanupStack::Pop();
+	return self;
+	}
+
+CTelephonyFunctions::~CTelephonyFunctions()
+/**
+Destructor
+*/
+	{
+
+	CleanUp();
+
+	if (iTelServerIsOpen)
+		{
+		iTelServer.Close();
+		}
+
+	iReqPendingTable.Close();
+	iReqStatusTable.Close();
+	iCallPool.Close();
+	iCallPoolStatus.Close();
+	iPhonePowerProperty.Close();
+	}
+
+/**
+Cleans up any outstanding "Open" objects.
+*/
+void CTelephonyFunctions::CleanUp()
+	{
+	for ( TInt i=0;i<iReqPendingTable.Count(); i++)
+		{
+		if(iReqPendingTable[i]!=EFalse)
+			{
+			User::RequestComplete(iReqStatusTable[i], KErrCancel);
+			}
+		}
+
+	iState = ECleaningUp;
+
+	if(iGetPhoneId!=NULL)
+		{
+		delete iGetPhoneId;
+		iGetPhoneId = NULL;
+		}
+	if(iGetSubscriberId!=NULL)
+		{
+		delete iGetSubscriberId;
+		iGetSubscriberId = NULL;
+		}
+	if(iGetIndicator!=NULL)
+		{
+		delete iGetIndicator;
+		iGetIndicator = NULL;
+		}
+	if(iGetBatteryInfo!=NULL)
+		{
+		delete iGetBatteryInfo;
+		iGetBatteryInfo = NULL;
+		}
+	if(iGetSignalStrength!=NULL)
+		{
+		delete iGetSignalStrength;
+		iGetSignalStrength = NULL;
+		}
+	if(iGetIccLockInfo!=NULL)
+		{
+		delete iGetIccLockInfo;
+		iGetIccLockInfo = NULL;
+		}
+	if(iSendDTMFTones!=NULL)
+		{
+		delete iSendDTMFTones;
+		iSendDTMFTones = NULL;
+		}
+	if(iDialNewCall!=NULL)
+		{
+		delete iDialNewCall;
+		iDialNewCall = NULL;
+		}
+	if(iHold!=NULL)
+		{
+		delete iHold;
+		iHold = NULL;
+		}
+	if(iResume!=NULL)
+		{
+		delete iResume;
+		iResume = NULL;
+		}
+	if(iSwap!=NULL)
+		{
+		delete iSwap;
+		iSwap = NULL;
+		}
+	if(iHangup!=NULL)
+		{
+		delete iHangup;
+		iHangup = NULL;
+		}
+	if(iAnswerIncomingCall!=NULL)
+		{
+		delete iAnswerIncomingCall;
+		iAnswerIncomingCall = NULL;
+		}
+	if(iGetNetworkRegistrationStatus!=NULL)
+		{
+		delete iGetNetworkRegistrationStatus;
+		iGetNetworkRegistrationStatus = NULL;
+		}
+	if(iGetCurrentNetworkInfo!=NULL)
+		{
+		delete iGetCurrentNetworkInfo;
+		iGetCurrentNetworkInfo = NULL;
+		}
+	if(iGetCurrentNetworkName!=NULL)
+		{
+		delete iGetCurrentNetworkName;
+		iGetCurrentNetworkName = NULL;
+		}
+	if(iGetOperatorName!=NULL)
+		{
+		delete iGetOperatorName;
+		iGetOperatorName = NULL;
+		}
+	if(iGetCFSupplementaryServiceStatus!=NULL)
+		{
+		delete iGetCFSupplementaryServiceStatus;
+		iGetCFSupplementaryServiceStatus = NULL;
+		}
+	if(iGetCBSupplementaryServiceStatus!=NULL)
+		{
+		delete iGetCBSupplementaryServiceStatus;
+		iGetCBSupplementaryServiceStatus = NULL;
+		}
+	if(iGetCWSupplementaryServiceStatus!=NULL)
+		{
+		delete iGetCWSupplementaryServiceStatus;
+		iGetCWSupplementaryServiceStatus = NULL;
+		}
+	if(iGetIdentityServiceStatus!=NULL)
+		{
+		delete iGetIdentityServiceStatus;
+		iGetIdentityServiceStatus = NULL;
+		}
+	if(iFlightModeChange!=NULL)
+		{
+		delete iFlightModeChange;
+		iFlightModeChange = NULL;
+		}
+	if(iNotifyIndicator!=NULL)
+		{
+		delete iNotifyIndicator;
+		iNotifyIndicator = NULL;
+		}
+	if(iNotifyBatteryInfo!=NULL)
+		{
+		delete iNotifyBatteryInfo;
+		iNotifyBatteryInfo = NULL;
+		}
+	if(iNotifySignalStrength!=NULL)
+		{
+		delete iNotifySignalStrength;
+		iNotifySignalStrength = NULL;
+		}
+	if(iNotifyIccLockInfo!=NULL)
+		{
+		delete iNotifyIccLockInfo;
+		iNotifyIccLockInfo = NULL;
+		}
+	if(iNotifyNetworkRegStatus!=NULL)
+		{
+		delete iNotifyNetworkRegStatus;
+		iNotifyNetworkRegStatus = NULL;
+		}
+	if(iNotifyCurrentNetworkInfo!=NULL)
+		{
+		delete iNotifyCurrentNetworkInfo;
+		iNotifyCurrentNetworkInfo = NULL;
+		}
+	if(iNotifyOwnedCall1Status!=NULL)
+		{
+		delete iNotifyOwnedCall1Status;
+		iNotifyOwnedCall1Status = NULL;
+		}
+	if(iNotifyOwnedCall2Status!=NULL)
+		{
+		delete iNotifyOwnedCall2Status;
+		iNotifyOwnedCall2Status = NULL;
+		}
+	if(iNotifyOwnedCall1RemoteInfo!=NULL)
+		{
+		delete iNotifyOwnedCall1RemoteInfo;
+		iNotifyOwnedCall1RemoteInfo = NULL;
+		}
+	if(iNotifyOwnedCall2RemoteInfo!=NULL)
+		{
+		delete iNotifyOwnedCall2RemoteInfo;
+		iNotifyOwnedCall2RemoteInfo = NULL;
+		}
+
+	// Delete the internal active objects last
+	if(iInternalNotifyVoiceLineStatus!=NULL)
+		{
+		delete iInternalNotifyVoiceLineStatus;
+		iInternalNotifyVoiceLineStatus = NULL;
+		}
+	if (iInternalNotifyIncomingCall!=NULL)
+		{
+		delete iInternalNotifyIncomingCall;
+		iInternalNotifyIncomingCall = NULL;
+		}
+
+	if(iCallIsOpen)
+		{
+		iCallIsOpen = EFalse;
+		iCall.Close();
+		}
+
+	for(TInt k = 0; k < iCallPool.Count(); k++)
+		{
+		iCallPool[k].Close();
+		}
+		
+	for(TInt k = 0; k < iCallPoolStatus.Count(); k++)
+		{
+		iCallPoolStatus[k] = EUnset;
+		}
+
+	if(iLineIsDataOpen)
+		{
+		iLineIsDataOpen = EFalse;
+		iLineData.Close();
+		}
+
+	if(iLineIsVoiceOpen)
+		{
+		iLineIsVoiceOpen = EFalse;
+		iLineVoice.Close();
+		}
+
+	if(iLineIsFaxOpen)
+		{
+		iLineIsFaxOpen = EFalse;
+		iLineFax.Close();
+		}
+
+	if(iPhoneIsOpen)
+		{
+		iPhoneIsOpen = EFalse;
+		iPhone.Close();
+		}
+	iState = EIdle;	// all cleaned up.
+	}
+
+
+CTelephonyFunctions::CTelephonyFunctions()
+/**
+First-phase constructor
+
+private function which cannot Leave().
+*/
+: iState(EIdle),
+  iReqStatusTable(EMaxNumberOperations),
+  iReqPendingTable(EMaxNumberOperations),  
+  iCallPool(CTelephony::EISVMaxNumOfCalls),
+  iCallPoolStatus(CTelephony::EISVMaxNumOfCalls)
+	{
+	}
+
+
+void CTelephonyFunctions::ConstructL()
+/**
+Second-phase constructor
+*/
+	{
+#ifdef __WINS__
+	// When bootstrapping C32 we have to avoid the PhBkSyncServer being started, since
+  	// it needs a different CommDB
+	_LIT(KPhbkSyncCMI, "phbsync.cmi");
+	TInt err = StartC32WithCMISuppressions(KPhbkSyncCMI);		// Start Comms server if not already active.
+	if( err!=KErrNone && err!=KErrAlreadyExists )
+		{
+		User::Leave(err);
+		}
+
+#endif
+	User::LeaveIfError(iTelServer.Connect());
+	iTelServerIsOpen = ETrue;
+	User::LeaveIfError(iPhonePowerProperty.Attach(KUidSystemCategory, KUidPhonePwr.iUid));
+
+	for( TInt i=0; i<EMaxNumberOperations; i++)
+		{
+		TRequestStatus dummy(KErrNone);
+		iReqPendingTable.Append(EFalse);
+		iReqStatusTable.Append(&dummy);
+		}
+	for( TInt j=0; j<CTelephony::EISVMaxNumOfCalls; j++)
+		{
+		RMobileCall aDummyCall;
+		iCallPool.Append(aDummyCall);
+		iCallPoolStatus.Append(EUnset);
+		}
+
+	__ASSERT_DEBUG(iState==EIdle, User::Invariant());
+
+	InitialisePhoneL();
+	}
+
+
+void CTelephonyFunctions::GetCommDbTSYnameL(TDes& aTsyName)
+	{
+#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY
+	CMDBSession* db = CMDBSession::NewL(KCDVersion1_2);
+#else
+	CMDBSession* db = CMDBSession::NewL(KCDVersion1_1);
+#endif
+	CleanupStack::PushL(db);
+
+	CMDBField<TDesC>* globalSettingField = new(ELeave) CMDBField<TDesC>(KCDTIdBearerAvailabilityCheckTSY);
+	CleanupStack::PushL(globalSettingField);
+	globalSettingField->SetRecordId(1);
+	globalSettingField->SetMaxLengthL(KMaxTextLength);
+	globalSettingField->LoadL(*db);
+	aTsyName = *globalSettingField;
+	CleanupStack::PopAndDestroy(globalSettingField);
+
+	CleanupStack::PopAndDestroy(db);
+	}
+
+
+void CTelephonyFunctions::InitialisePhoneL()
+/**
+Finds the first data-Line and Open()'s the Phone and Line.
+
+@leave	Leaves if underlying ETEL.DLL returns error,
+or if we can't find a suitable Phone/Line or can't open it.
+*/
+	{
+	TBuf<KCommsDbSvrMaxFieldLength> tsyName;
+	GetCommDbTSYnameL(tsyName);
+
+	User::LeaveIfError(iTelServer.LoadPhoneModule(tsyName));
+
+	TInt numPhones;
+	User::LeaveIfError(iTelServer.EnumeratePhones(numPhones));
+
+	TInt phoneIndx;
+	TInt ret = KErrHardwareNotAvailable;
+
+	RPhone::TLineInfo lineInfo;
+	for(phoneIndx=0; phoneIndx<numPhones; phoneIndx++)
+		{
+		RTelServer::TPhoneInfo tInfo;
+		ret = iTelServer.GetPhoneInfo(phoneIndx, tInfo);
+		if(ret != KErrNone)
+			{
+			continue;
+			}
+		
+		ret = iPhone.Open(iTelServer, tInfo.iName);	
+		if(ret != KErrNone)
+			{
+			continue;
+			}
+
+		iPhoneIsOpen = ETrue;
+
+		RPhone::TStatus status;
+		User::LeaveIfError(iPhone.GetStatus(status));
+		if(status.iModemDetected!=RPhone::EDetectedPresent)
+			{
+			ret = iPhone.Initialise();
+			if(ret != KErrNone)
+				{
+				iPhone.Close();
+				iPhoneIsOpen = EFalse;
+				continue;
+				}
+			}
+
+		TInt lines;
+		ret = iPhone.EnumerateLines(lines);
+		if(ret != KErrNone)
+			{
+			iPhone.Close();
+			iPhoneIsOpen = EFalse;
+			continue;
+			}
+
+		if(lines<1)
+			{
+			ret = KErrEtelWrongModemType;
+			iPhone.Close();
+			iPhoneIsOpen = EFalse;
+			continue;
+			}
+
+		TInt lineIndx;
+		TBool lineVoiceFound=EFalse, lineFaxFound=EFalse, lineDataFound=EFalse;
+		for(lineIndx=0; lineIndx<lines; lineIndx++)
+			{
+			if(iPhone.GetLineInfo(lineIndx, lineInfo) != KErrNone)
+				{
+				continue;
+				}
+
+			if((lineInfo.iLineCapsFlags & RLine::KCapsVoice)&&(!lineVoiceFound))
+				{
+				User::LeaveIfError(iLineVoice.Open(iPhone, lineInfo.iName));
+				iLineIsVoiceOpen = ETrue;
+				lineVoiceFound = ETrue;
+				iLineVoiceName.Copy(lineInfo.iName);
+				continue;
+				}
+			else if((lineInfo.iLineCapsFlags & RLine::KCapsData)&&(!lineDataFound))
+				{
+				User::LeaveIfError(iLineData.Open(iPhone, lineInfo.iName));
+				iLineIsDataOpen = ETrue;
+				lineDataFound = ETrue;
+				continue;
+				}
+			else if((lineInfo.iLineCapsFlags & RLine::KCapsFax)&&(!lineFaxFound))
+				{
+				User::LeaveIfError(iLineFax.Open(iPhone, lineInfo.iName));
+				iLineIsFaxOpen = ETrue;
+				lineFaxFound = ETrue;
+				continue;
+				}
+
+			}
+
+		if(!iLineIsVoiceOpen)
+			{
+			ret = KErrEtelWrongModemType;
+			iPhone.Close();
+			iPhoneIsOpen = EFalse;
+			continue;
+			}
+
+		//get TSY version
+		TBool result;
+		iTsyVersion = KETelExtMultimodeV3;
+		User::LeaveIfError(iTelServer.IsSupportedByModule(tsyName, iTsyVersion, result));
+		if(!result)
+			{
+			iTsyVersion = KETelExtMultimodeV2;
+			User::LeaveIfError(iTelServer.IsSupportedByModule(tsyName, iTsyVersion, result));
+			if(!result)
+				{
+				iTsyVersion = KETelExtMultimodeV1;
+				User::LeaveIfError(iTelServer.IsSupportedByModule(tsyName, iTsyVersion, result));
+				if(!result)
+					{
+					iTsyVersion = KNoMultimodeTsy;
+					}
+				}
+			}
+
+		//
+		// A CTelephonyFunctions object is always listening for a change
+		// in the line status and for an incoming call.
+		// The iInternalNotifyVoiceLineStatus and iInternalNotifyIncoming
+		// call objects persist throughout this object's lifetime.
+		// Create the internal active objects and post the first request.
+		//
+		iInternalNotifyIncomingCall=CNotifyIncomingCallAct::NewL(this);
+		iInternalNotifyIncomingCall->NotifyIncomingCall();
+		iInternalNotifyVoiceLineStatus=CNotifyLineStatusAct::NewL(this, CTelephonyFunctions::ENotifyVoiceLineStatus, *iInternalNotifyIncomingCall);
+		iInternalNotifyVoiceLineStatus->NotifyLineStatus(NULL);
+
+		//
+		// We have found a valid phone to use...
+		//
+		break;
+		}
+
+	//
+	// ret will be KErrNone if a valid phone was found...
+	//
+	User::LeaveIfError(ret);
+	}
+
+/**
+Cancel the outstanding async request.
+*/
+TInt CTelephonyFunctions::CancelAsync(CTelephony::TCancellationRequest aCancel)
+	{
+	switch(aCancel)
+		{
+		case CTelephony::EGetPhoneIdCancel:
+			if((iGetPhoneId==NULL)||
+				(IsRequestPending(EGetPhoneId)==EFalse))
+				return KErrTelephonyOutOfSequence;
+			else
+				{
+				delete iGetPhoneId;
+				iGetPhoneId=NULL;
+				}
+			break;
+		case CTelephony::EGetSubscriberIdCancel:
+			if((iGetSubscriberId==NULL)||
+				(IsRequestPending(EGetSubscriberId)==EFalse))
+				return KErrTelephonyOutOfSequence;
+			else
+				{
+				delete iGetSubscriberId;
+				iGetSubscriberId=NULL;
+				}
+			break;
+		case CTelephony::EGetIndicatorCancel:
+			if((iGetIndicator==NULL)||
+				(IsRequestPending(EGetIndicator)==EFalse))
+				return KErrTelephonyOutOfSequence;
+			else
+				{
+				delete iGetIndicator;
+				iGetIndicator=NULL;
+				}
+			break;
+		case CTelephony::EGetBatteryInfoCancel:
+			if((iGetBatteryInfo==NULL)||
+				(IsRequestPending(EGetBatteryInfo)==EFalse))
+				return KErrTelephonyOutOfSequence;
+			else
+				{
+				delete iGetBatteryInfo;
+				iGetBatteryInfo=NULL;
+				}
+			break;
+		case CTelephony::EGetSignalStrengthCancel:
+			if((iGetSignalStrength==NULL)||
+				(IsRequestPending(EGetSignalStrength)==EFalse))
+				return KErrTelephonyOutOfSequence;
+			else
+				{
+				delete iGetSignalStrength;
+				iGetSignalStrength=NULL;
+				}
+			break;
+		case CTelephony::EGetLockInfoCancel:
+			if((iGetIccLockInfo==NULL)||
+				(IsRequestPending(EGetIccLockInfo)==EFalse))
+				return KErrTelephonyOutOfSequence;
+			else
+				{
+				delete iGetIccLockInfo;
+				iGetIccLockInfo=NULL;
+				}
+			break;
+		case CTelephony::ESendDTMFTonesCancel:
+			if((iSendDTMFTones==NULL)||
+				(IsRequestPending(ESendDTMFTones)==EFalse))
+				return KErrTelephonyOutOfSequence;
+			else
+				{
+				delete iSendDTMFTones;
+				iSendDTMFTones=NULL;
+				}
+			break;
+		case CTelephony::EDialNewCallCancel:
+			if((iDialNewCall==NULL)||
+				(IsRequestPending(EDialNewCall)==EFalse))
+				return KErrTelephonyOutOfSequence;
+			else
+				{
+				delete iDialNewCall;
+				iDialNewCall=NULL;
+				}
+			break;
+		case CTelephony::EHoldCancel:
+			if((iHold==NULL)||
+				(IsRequestPending(EHold)==EFalse))
+				return KErrTelephonyOutOfSequence;
+			else
+				{
+				delete iHold;
+				iHold=NULL;
+				}
+			break;
+		case CTelephony::EResumeCancel:
+			if((iResume==NULL)||
+				(IsRequestPending(EResume)==EFalse))
+				return KErrTelephonyOutOfSequence;
+			else
+				{
+				delete iResume;
+				iResume=NULL;
+				}
+			break;
+		case CTelephony::ESwapCancel:
+			if((iSwap==NULL)||
+				(IsRequestPending(ESwap)==EFalse))
+				return KErrTelephonyOutOfSequence;
+			else
+				{
+				delete iSwap;
+				iSwap=NULL;
+				}
+			break;
+		case CTelephony::EHangupCancel:
+			if((iHangup==NULL)||
+				(IsRequestPending(EHangup)==EFalse))
+				return KErrTelephonyOutOfSequence;
+			else
+				{
+				delete iHangup;
+				iHangup=NULL;
+				}
+			break;
+		case CTelephony::EAnswerIncomingCallCancel:
+			if((iAnswerIncomingCall==NULL)||
+				(IsRequestPending(EAnswerIncomingCall)==EFalse))
+				return KErrTelephonyOutOfSequence;
+			else
+				{
+				delete iAnswerIncomingCall;
+				iAnswerIncomingCall=NULL;
+				}
+			break;
+		case CTelephony::EGetNetworkRegistrationStatusCancel:
+			if((iGetNetworkRegistrationStatus==NULL)||
+				(IsRequestPending(EGetNetworkRegistrationStatus)==EFalse))
+				return KErrTelephonyOutOfSequence;
+			else
+				{
+				delete iGetNetworkRegistrationStatus;
+				iGetNetworkRegistrationStatus=NULL;
+				}
+			break;
+		case CTelephony::EGetCurrentNetworkInfoCancel:
+			if((iGetCurrentNetworkInfo==NULL)||
+				(IsRequestPending(EGetCurrentNetworkInfo)==EFalse))
+				return KErrTelephonyOutOfSequence;
+			else
+				{
+				delete iGetCurrentNetworkInfo;
+				iGetCurrentNetworkInfo=NULL;
+				}
+			break;
+		case CTelephony::EGetCurrentNetworkNameCancel:
+			if((iGetCurrentNetworkName==NULL)||
+				(IsRequestPending(EGetCurrentNetworkName)==EFalse))
+				return KErrTelephonyOutOfSequence;
+			else
+				{
+				delete iGetCurrentNetworkName;
+				iGetCurrentNetworkName=NULL;
+				}
+			break;
+		case CTelephony::EGetOperatorNameCancel:
+			if((iGetOperatorName==NULL)||
+				(IsRequestPending(EGetOperatorName)==EFalse))
+				return KErrTelephonyOutOfSequence;
+			else
+				{
+				delete iGetOperatorName;
+				iGetOperatorName=NULL;
+				}
+			break;
+		case CTelephony::EGetCallForwardingStatusCancel:
+			if((iGetCFSupplementaryServiceStatus==NULL)||
+				(IsRequestPending(EGetCFSupplServicesStatus)==EFalse))
+				return KErrTelephonyOutOfSequence;
+			else
+				{
+				delete iGetCFSupplementaryServiceStatus;
+				iGetCFSupplementaryServiceStatus=NULL;
+				}
+			break;
+		case CTelephony::EGetCallBarringStatusCancel:
+			if((iGetCBSupplementaryServiceStatus==NULL)||
+				(IsRequestPending(EGetCBSupplServicesStatus)==EFalse))
+				return KErrTelephonyOutOfSequence;
+			else
+				{
+				delete iGetCBSupplementaryServiceStatus;
+				iGetCBSupplementaryServiceStatus=NULL;
+				}
+			break;
+		case CTelephony::EGetCallWaitingStatusCancel:
+			if((iGetCWSupplementaryServiceStatus==NULL)||
+				(IsRequestPending(EGetCWSupplServicesStatus)==EFalse))
+				return KErrTelephonyOutOfSequence;
+			else
+				{
+				delete iGetCWSupplementaryServiceStatus;
+				iGetCWSupplementaryServiceStatus=NULL;
+				}
+			break;
+		case CTelephony::EGetIdentityServiceStatusCancel:
+			if((iGetIdentityServiceStatus==NULL)||
+				(IsRequestPending(EGetIdentityServiceStatus)==EFalse))
+				return KErrTelephonyOutOfSequence;
+			else
+				{
+				delete iGetIdentityServiceStatus;
+				iGetIdentityServiceStatus=NULL;
+				}
+			break;
+		case CTelephony::EFlightModeChangeCancel:
+			if((iFlightModeChange==NULL)||
+				(IsRequestPending(EFlightModeChange)==EFalse))
+				return KErrTelephonyOutOfSequence;
+			else
+				{
+				delete iFlightModeChange;
+				iFlightModeChange=NULL;
+				}
+			break;
+		case CTelephony::EIndicatorChangeCancel:
+			if((iNotifyIndicator==NULL)||
+				(IsRequestPending(ENotifyIndicator)==EFalse))
+				return KErrTelephonyOutOfSequence;
+			else
+				{
+				delete iNotifyIndicator;
+				iNotifyIndicator=NULL;
+				}
+			break;
+		case CTelephony::EBatteryInfoChangeCancel:
+			if((iNotifyBatteryInfo==NULL)||
+				(IsRequestPending(ENotifyBatteryInfo)==EFalse))
+				return KErrTelephonyOutOfSequence;
+			else
+				{
+				delete iNotifyBatteryInfo;
+				iNotifyBatteryInfo=NULL;
+				}
+			break;
+		case CTelephony::ESignalStrengthChangeCancel:
+			if((iNotifySignalStrength==NULL)||
+				(IsRequestPending(ENotifySignalStrength)==EFalse))
+				return KErrTelephonyOutOfSequence;
+			else
+				{
+				delete iNotifySignalStrength;
+				iNotifySignalStrength=NULL;
+				}
+			break;
+		case CTelephony::EPin1LockInfoChangeCancel:
+			if((iNotifyIccLockInfo==NULL)||
+				(IsRequestPending(ENotifyPin1LockInfo)==EFalse))
+				{
+				return KErrTelephonyOutOfSequence;
+				}
+			else if (IsRequestPending(ENotifyPin2LockInfo))
+				{
+				CompleteRequest(ENotifyPin1LockInfo,KErrCancel);
+				}
+			else
+				{
+				delete iNotifyIccLockInfo;
+				iNotifyIccLockInfo=NULL;
+				}
+
+			break;
+		case CTelephony::EPin2LockInfoChangeCancel:
+			if((iNotifyIccLockInfo==NULL)||
+				(IsRequestPending(ENotifyPin2LockInfo)==EFalse))
+				{
+				return KErrTelephonyOutOfSequence;
+				}
+			else if (IsRequestPending(ENotifyPin1LockInfo))
+				{
+				CompleteRequest(ENotifyPin2LockInfo,KErrCancel);
+				}
+			else
+				{
+				delete iNotifyIccLockInfo;
+				iNotifyIccLockInfo=NULL;
+				}
+			break;
+		case CTelephony::ENetworkRegistrationStatusChangeCancel:
+			if((iNotifyNetworkRegStatus==NULL)||
+				(IsRequestPending(ENotifyNetworkRegistrationStatus)==EFalse))
+				return KErrTelephonyOutOfSequence;
+			else
+				{
+				delete iNotifyNetworkRegStatus;
+				iNotifyNetworkRegStatus=NULL;
+				}
+			break;
+		case CTelephony::ECurrentNetworkInfoChangeCancel:
+			if((iNotifyCurrentNetworkInfo==NULL)||
+				(IsRequestPending(ENotifyCurrentNetworkInfo)==EFalse))
+				return KErrTelephonyOutOfSequence;
+			else
+				{
+				delete iNotifyCurrentNetworkInfo;
+				iNotifyCurrentNetworkInfo=NULL;
+				}
+			break;
+		case CTelephony::EOwnedCall1StatusChangeCancel:
+			if((iNotifyOwnedCall1Status==NULL)||
+				(IsRequestPending(ENotifyOwnedCall1Status)==EFalse))
+				return KErrTelephonyOutOfSequence;
+			else
+				{
+				delete iNotifyOwnedCall1Status;
+				iNotifyOwnedCall1Status=NULL;
+				}
+			break;
+		case CTelephony::EOwnedCall2StatusChangeCancel:
+			if((iNotifyOwnedCall2Status==NULL)||
+				(IsRequestPending(ENotifyOwnedCall2Status)==EFalse))
+				return KErrTelephonyOutOfSequence;
+			else
+				{
+				delete iNotifyOwnedCall2Status;
+				iNotifyOwnedCall2Status=NULL;
+				}
+			break;
+		case CTelephony::EVoiceLineStatusChangeCancel:
+			if (IsRequestPending(ENotifyVoiceLineStatus)==EFalse)
+				{
+				return KErrTelephonyOutOfSequence;
+				}
+			else
+				{
+				// Notifies the iInternalNotifyVoiceLineStatus active
+				// object that the client is no longer interested
+				// in being notified of line status changes.
+				// The AO will then complete the request back to the
+				// client with a status of KErrCancel.
+				// The AO will still continue to monitor for line
+				// status changes but now the result will not be
+				// returned to the client.
+				if (iInternalNotifyVoiceLineStatus)
+					iInternalNotifyVoiceLineStatus->CancelFromClient();
+				}
+			break;
+		case CTelephony::EFaxLineStatusChangeCancel:
+			return KErrNotSupported;
+		case CTelephony::EDataLineStatusChangeCancel:
+			return KErrNotSupported;
+		case CTelephony::EOwnedCall1RemotePartyInfoChangeCancel:
+			if((iNotifyOwnedCall1RemoteInfo==NULL)||
+				(IsRequestPending(ENotifyOwnedCall1RemoteInfo)==EFalse))
+				return KErrTelephonyOutOfSequence;
+			else
+				{
+				delete iNotifyOwnedCall1RemoteInfo;
+				iNotifyOwnedCall1RemoteInfo=NULL;
+				}
+			break;
+		case CTelephony::EOwnedCall2RemotePartyInfoChangeCancel:
+			if((iNotifyOwnedCall2RemoteInfo==NULL)||
+				(IsRequestPending(ENotifyOwnedCall2RemoteInfo)==EFalse))
+				return KErrTelephonyOutOfSequence;
+			else
+				{
+				delete iNotifyOwnedCall2RemoteInfo;
+				iNotifyOwnedCall2RemoteInfo=NULL;
+				}
+			break;
+		default:
+			return KErrNotSupported;
+		}
+
+	return KErrNone;
+	}
+
+/**
+Send a notification request.
+
+@param aRequestStatus The request status to be returned when an event
+                      occurs for client notification.
+@param aEvent The notification event the caller is requesting.
+@param aDes Packaged data returned by the TSY when an event for notification occurs.
+*/
+TInt CTelephonyFunctions::NotifyChangeL(TRequestStatus& aRequestStatus,
+             const CTelephony::TNotificationEvent& aEvent, TDes8& aDes)
+	{
+	TInt err;
+	switch(aEvent)
+		{
+		case CTelephony::EFlightModeChange:
+			err = NotifyFlightModeL(aRequestStatus, aDes);
+			break;
+
+		case CTelephony::EOwnedCall1RemotePartyInfoChange:
+			err = NotifyOwnedCall1RemotePartyInfoL(aRequestStatus, aDes);
+			break;
+
+		case CTelephony::EOwnedCall2RemotePartyInfoChange:
+			err = NotifyOwnedCall2RemotePartyInfoL(aRequestStatus, aDes);
+			break;
+
+		case CTelephony::EVoiceLineStatusChange:
+			err = NotifyVoiceLineStatusL(aRequestStatus, aDes);
+			break;
+
+		case CTelephony::EFaxLineStatusChange:
+			err = KErrNotSupported;
+			break;
+
+		case CTelephony::EDataLineStatusChange:
+			err = KErrNotSupported;
+			break;
+
+		case CTelephony::EOwnedCall1StatusChange:
+			err = NotifyOwnedCall1StatusL(aRequestStatus, aDes);
+			break;
+
+		case CTelephony::EOwnedCall2StatusChange:
+			err = NotifyOwnedCall2StatusL(aRequestStatus, aDes);
+			break;
+
+		case CTelephony::EIndicatorChange:
+			err = NotifyIndicatorL(aRequestStatus, aDes);
+			break;
+
+		case CTelephony::EPin1LockInfoChange:
+		case CTelephony::EPin2LockInfoChange:
+			err = NotifyPinLockInfoL(aRequestStatus, aEvent, aDes);
+			break;
+
+		case CTelephony::EBatteryInfoChange:
+			err = NotifyBatteryInfoL(aRequestStatus, aDes);
+			break;
+
+		case CTelephony::ESignalStrengthChange:
+			err = NotifySignalStrengthL(aRequestStatus, aDes);
+			break;
+
+		case CTelephony::ENetworkRegistrationStatusChange:
+			err = NotifyNetworkRegistrationStatusL(aRequestStatus, aDes);
+			break;
+
+		case CTelephony::ECurrentNetworkInfoChange:
+			err = NotifyCurrentNetworkInfoL(aRequestStatus, aDes);
+			break;
+		default:
+			err = KErrArgument;
+		}
+	return err;
+	}
+
+TInt CTelephonyFunctions::NotifyFlightModeL(TRequestStatus& aRequestStatus, TDes8& aDes)
+/**
+Post a Flight mode notification request
+*/
+	{
+	if (IsRequestPending(EFlightModeChange)!=EFalse)
+		{
+		return KErrInUse;
+		}
+	else
+		{
+		SetRequestPending(CTelephonyFunctions::EFlightModeChange, ETrue);
+		}
+
+	if(iFlightModeChange==NULL)
+		{
+		iFlightModeChange=CFlightModeChangeAct::NewL(this);
+		}
+	iReqStatusTable[EFlightModeChange] = &aRequestStatus;
+
+	iFlightModeChange->FlightModeChangeL(aDes);
+	return KErrNone;
+	}
+
+TInt CTelephonyFunctions::NotifyOwnedCall1RemotePartyInfoL(TRequestStatus& aRequestStatus, TDes8& aDes)
+/**
+Post a remote party info call 1 notification request
+*/
+	{
+	if (IsRequestPending(ENotifyOwnedCall1RemoteInfo)!=EFalse)
+		{
+		return KErrInUse;
+		}
+	else
+		{
+		SetRequestPending(CTelephonyFunctions::ENotifyOwnedCall1RemoteInfo, ETrue);
+		}
+
+	if(iCallPoolStatus[CTelephony::EISVCall1]==EUnset)
+		{
+		return KErrAccessDenied;
+		}
+
+	if(iNotifyOwnedCall1RemoteInfo==NULL)
+		{
+		iNotifyOwnedCall1RemoteInfo=CNotifyRemotePartyInfoAct::NewL(this, CTelephonyFunctions::ENotifyOwnedCall1RemoteInfo);
+		}
+
+	iReqStatusTable[ENotifyOwnedCall1RemoteInfo] = &aRequestStatus;
+
+	iNotifyOwnedCall1RemoteInfo->NotifyRemotePartyInfo(aDes, CTelephony::EISVCall1);
+	return KErrNone;
+	}
+
+TInt CTelephonyFunctions::NotifyOwnedCall2RemotePartyInfoL(TRequestStatus& aRequestStatus, TDes8& aDes)
+/**
+Post aremote party info call 2 notification request
+*/
+	{
+	if (IsRequestPending(ENotifyOwnedCall2RemoteInfo)!=EFalse)
+		{
+		return KErrInUse;
+		}
+	else
+		{
+		SetRequestPending(CTelephonyFunctions::ENotifyOwnedCall2RemoteInfo, ETrue);
+		}
+
+	if(iCallPoolStatus[CTelephony::EISVCall2]==EUnset)
+		{
+		return KErrAccessDenied;
+		}
+
+	if(iNotifyOwnedCall2RemoteInfo==NULL)
+		{
+		iNotifyOwnedCall2RemoteInfo=CNotifyRemotePartyInfoAct::NewL(this, CTelephonyFunctions::ENotifyOwnedCall2RemoteInfo);
+		}
+
+	iReqStatusTable[ENotifyOwnedCall2RemoteInfo] = &aRequestStatus;
+
+	iNotifyOwnedCall2RemoteInfo->NotifyRemotePartyInfo(aDes, CTelephony::EISVCall2);
+	return KErrNone;
+	}
+
+/**
+Post a voice line status notification request.
+
+@param aRequestStatus The request status.
+@param aDes Package containing TCallStatus which will store the resulting line status.
+*/
+TInt CTelephonyFunctions::NotifyVoiceLineStatusL(TRequestStatus& aRequestStatus, TDes8& aDes)
+	{
+	if (IsRequestPending(ENotifyVoiceLineStatus)!=EFalse)
+		{
+		return KErrInUse;
+		}
+	else
+		{
+		SetRequestPending(CTelephonyFunctions::ENotifyVoiceLineStatus, ETrue);
+		}
+	iReqStatusTable[ENotifyVoiceLineStatus] = &aRequestStatus;
+
+	iInternalNotifyVoiceLineStatus->NotifyLineStatus(&aDes);
+
+	return KErrNone;
+	}
+
+TInt CTelephonyFunctions::NotifyOwnedCall1StatusL(TRequestStatus& aRequestStatus, TDes8& aDes)
+/**
+Post a call 1 status change notification request
+*/
+	{
+	if (IsRequestPending(ENotifyOwnedCall1Status)!=EFalse)
+		{
+		return KErrInUse;
+		}
+	else
+		{
+		SetRequestPending(CTelephonyFunctions::ENotifyOwnedCall1Status, ETrue);
+		}
+	if(iCallPoolStatus[CTelephony::EISVCall1]==EUnset)
+		{
+		return KErrAccessDenied;
+		}
+
+	if(iNotifyOwnedCall1Status==NULL)
+		{
+		iNotifyOwnedCall1Status=CNotifyCallStatusAct::NewL(this, CTelephonyFunctions::ENotifyOwnedCall1Status);
+		}
+
+	iReqStatusTable[ENotifyOwnedCall1Status] = &aRequestStatus;
+
+	iNotifyOwnedCall1Status->NotifyCallStatus(aDes, CTelephony::EISVCall1);
+	return KErrNone;
+	}
+
+TInt CTelephonyFunctions::NotifyOwnedCall2StatusL(TRequestStatus& aRequestStatus, TDes8& aDes)
+/**
+Post a call 2 status change notification request
+*/
+	{
+	if (IsRequestPending(ENotifyOwnedCall2Status)!=EFalse)
+		{
+		return KErrInUse;
+		}
+	else
+		{
+		SetRequestPending(CTelephonyFunctions::ENotifyOwnedCall2Status, ETrue);
+		}
+	if(iCallPoolStatus[CTelephony::EISVCall2]==EUnset)
+		{
+		return KErrAccessDenied;
+		}
+
+	if(iNotifyOwnedCall2Status==NULL)
+		{
+		iNotifyOwnedCall2Status=CNotifyCallStatusAct::NewL(this, CTelephonyFunctions::ENotifyOwnedCall2Status);
+		}
+
+	iReqStatusTable[ENotifyOwnedCall2Status] = &aRequestStatus;
+
+	iNotifyOwnedCall2Status->NotifyCallStatus(aDes, CTelephony::EISVCall2);
+	return KErrNone;
+	}
+
+TInt CTelephonyFunctions::NotifyIndicatorL(TRequestStatus& aRequestStatus, TDes8& aDes)
+/**
+Post a indicator notification request
+*/
+	{
+	if (IsRequestPending(ENotifyIndicator)!=EFalse)
+		{
+		return KErrInUse;
+		}
+	else
+		{
+		SetRequestPending(CTelephonyFunctions::ENotifyIndicator, ETrue);
+		}
+
+	if(iNotifyIndicator==NULL)
+		{
+		iNotifyIndicator=CNotifyIndicatorAct::NewL(this);
+		}
+
+	iReqStatusTable[ENotifyIndicator] = &aRequestStatus;
+
+	iNotifyIndicator->NotifyIndicator(aDes);
+	return KErrNone;
+	}
+
+TInt CTelephonyFunctions::NotifyPinLockInfoL(TRequestStatus& aRequestStatus, const CTelephony::TNotificationEvent& aEvent, TDes8& aDes)
+/**
+Post a pin lock change  notification request
+*/
+	{
+	CTelephony::TIccLock lock;
+	if(aEvent == CTelephony::EPin1LockInfoChange)
+		{
+		lock = CTelephony::ELockPin1;
+		if (IsRequestPending(ENotifyPin1LockInfo))
+			{
+			return KErrInUse;
+			}
+		}
+	else if(aEvent == CTelephony::EPin2LockInfoChange)
+		{
+		lock = CTelephony::ELockPin2;
+		if (IsRequestPending(ENotifyPin2LockInfo))
+			{
+			return KErrInUse;
+			}
+		}
+	else
+		{
+		return KErrNotSupported;
+		}
+
+	if(iNotifyIccLockInfo==NULL)
+		{
+		iNotifyIccLockInfo=CNotifyIccLockInfoAct::NewL(this);
+		}
+
+	if (lock == CTelephony::ELockPin1)
+		{
+		SetRequestPending(CTelephonyFunctions::ENotifyPin1LockInfo, ETrue);
+		iReqStatusTable[ENotifyPin1LockInfo] = &aRequestStatus;
+		}
+	else if (lock == CTelephony::ELockPin2)
+		{
+		SetRequestPending(CTelephonyFunctions::ENotifyPin2LockInfo, ETrue);
+		iReqStatusTable[ENotifyPin2LockInfo] = &aRequestStatus;
+		}
+
+	iNotifyIccLockInfo->NotifyIccLockInfo(lock, aDes);
+	return KErrNone;
+	}
+
+TInt CTelephonyFunctions::NotifyBatteryInfoL(TRequestStatus& aRequestStatus, TDes8& aDes)
+/**
+Post a battery info change notification request
+*/
+	{
+	if (IsRequestPending(ENotifyBatteryInfo)!=EFalse)
+		{
+		return KErrInUse;
+		}
+	else
+		{
+		SetRequestPending(CTelephonyFunctions::ENotifyBatteryInfo, ETrue);
+		}
+
+	if(iNotifyBatteryInfo==NULL)
+		{
+		iNotifyBatteryInfo=CNotifyBatteryInfoAct::NewL(this);
+		}
+	iReqStatusTable[ENotifyBatteryInfo] = &aRequestStatus;
+
+	iNotifyBatteryInfo->NotifyBatteryInfo(aDes);
+	return KErrNone;
+	}
+
+TInt CTelephonyFunctions::NotifySignalStrengthL(TRequestStatus& aRequestStatus, TDes8& aDes)
+/**
+Post a signal strength change notification request
+*/
+	{
+	if (IsRequestPending(ENotifySignalStrength)!=EFalse)
+		{
+		return KErrInUse;
+		}
+	else
+		{
+		SetRequestPending(CTelephonyFunctions::ENotifySignalStrength, ETrue);
+		}
+
+	if(iNotifySignalStrength==NULL)
+		{
+		iNotifySignalStrength=CNotifySignalStrengthAct::NewL(this);
+		}
+
+	iReqStatusTable[ENotifySignalStrength] = &aRequestStatus;
+
+	iNotifySignalStrength->NotifySignalStrength(aDes);
+	return KErrNone;
+	}
+
+TInt CTelephonyFunctions::NotifyNetworkRegistrationStatusL(TRequestStatus& aRequestStatus, TDes8& aDes)
+/**
+Post a network registration change notification request
+*/
+	{
+	if (IsRequestPending(ENotifyNetworkRegistrationStatus)!=EFalse)
+		{
+		return KErrInUse;
+		}
+	else
+		{
+		SetRequestPending(CTelephonyFunctions::ENotifyNetworkRegistrationStatus, ETrue);
+		}
+
+	if(iNotifyNetworkRegStatus==NULL)
+		{
+		iNotifyNetworkRegStatus=CNotifyNetworkRegistrationStatusAct::NewL(this);
+		}
+	iReqStatusTable[ENotifyNetworkRegistrationStatus] = &aRequestStatus;
+
+	iNotifyNetworkRegStatus->NotifyNetworkRegistrationStatus(aDes);
+	return KErrNone;
+	}
+
+TInt CTelephonyFunctions::NotifyCurrentNetworkInfoL(TRequestStatus& aRequestStatus, TDes8& aDes)
+/**
+Post a current network info change notification request
+*/
+	{
+	if (IsRequestPending(ENotifyCurrentNetworkInfo)!=EFalse)
+		{
+		return KErrInUse;
+		}
+	else
+		{
+		SetRequestPending(CTelephonyFunctions::ENotifyCurrentNetworkInfo, ETrue);
+		}
+
+	if(iNotifyCurrentNetworkInfo==NULL)
+		{
+		iNotifyCurrentNetworkInfo=CNotifyCurrentNetworkInfoAct::NewL(this);
+		}
+	iReqStatusTable[CTelephonyFunctions::ENotifyCurrentNetworkInfo] = &aRequestStatus;
+
+	iNotifyCurrentNetworkInfo->NotifyCurrentNetworkInfo(aDes);
+	return KErrNone;
+	}
+
+TInt CTelephonyFunctions::GetISVCall(CTelephony::TCallId& aCallId)
+/**
+Return an available call ID.
+Also, continue looping though other call objects for opportunity to close them if they have become idle.
+*/
+	{
+	RMobileCall::TMobileCallStatus callStatus;
+	//get first free call object
+	TInt err;
+	TInt ret = KErrNotFound;
+	TInt foundACallId = EFalse;
+	for(int k=0;k<CTelephony::EISVMaxNumOfCalls;k++)
+		{
+		if(iCallPoolStatus[k]!=EUnset)
+			{
+			err = Call((CTelephony::TCallId)k)->GetMobileCallStatus(callStatus);
+			if(err==KErrNone && callStatus==RMobileCall::EStatusIdle)
+				{
+				if(!foundACallId)
+					{
+					aCallId=(CTelephony::TCallId)k;
+					foundACallId = ETrue;
+					ret = KErrNone;
+					}
+				else
+					{
+					CloseAndReset((CTelephony::TCallId)k);
+					}
+				}
+			}
+		else
+			{
+			if(!foundACallId)
+				{
+				aCallId=(CTelephony::TCallId)k;
+				foundACallId = ETrue;
+				ret = KErrNone;
+				}
+			}
+		}
+	return ret;
+	}
+
+TBool CTelephonyFunctions::IsFlightModeOn()
+/**
+Get Flight mode from SA
+*/
+	{
+	TInt newPhonePowerState;
+	if (iPhonePowerProperty.Get(newPhonePowerState) != KErrNone)
+		newPhonePowerState = ESAPhoneOff;
+	if(newPhonePowerState==ESAPhoneOn)
+		{
+		return EFalse;
+		}
+	else
+		{
+		return ETrue;
+		}
+	}
+
+void CTelephonyFunctions::CloseAndReset(const CTelephony::TCallId aCallId)
+/**
+Closes the open call object and resets its pool status back to Unset
+*/
+	{
+	//must close all outstanding notifiers invoked from this call session prior to closing the session.
+	if( aCallId ==  CTelephony::EISVCall1)
+		{
+		if(IsRequestPending(ENotifyOwnedCall1RemoteInfo))
+			{
+			CancelAsync(CTelephony::EOwnedCall1RemotePartyInfoChangeCancel);
+			}
+
+		if(IsRequestPending(ENotifyOwnedCall1Status))
+			{
+			CancelAsync(CTelephony::EOwnedCall1StatusChangeCancel);
+			}
+		}
+	else if(aCallId ==  CTelephony::EISVCall2)
+		{
+		if(IsRequestPending(ENotifyOwnedCall2RemoteInfo))
+			{
+			CancelAsync(CTelephony::EOwnedCall2RemotePartyInfoChangeCancel);
+			}
+
+		if(IsRequestPending(ENotifyOwnedCall2Status))
+			{
+			CancelAsync(CTelephony::EOwnedCall2StatusChangeCancel);
+			}
+		}
+
+	//close the call session
+	Call(aCallId)->Close();
+	iCallPoolStatus[aCallId] = EUnset;
+	}
+
+void CTelephonyFunctions::ResetPendingNotifyRequest(CTelephony::TNotificationEvent aEvent)
+/**
+Reset the pending notify request flag
+*/
+	{
+	switch(aEvent)
+		{
+		case CTelephony::EFlightModeChange:
+			SetRequestPending(CTelephonyFunctions::EFlightModeChange, EFalse);
+			break;
+		case CTelephony::EOwnedCall1RemotePartyInfoChange:
+			SetRequestPending(CTelephonyFunctions::ENotifyOwnedCall1RemoteInfo, EFalse);
+			break;
+		case CTelephony::EOwnedCall2RemotePartyInfoChange:
+			SetRequestPending(CTelephonyFunctions::ENotifyOwnedCall2RemoteInfo, EFalse);
+			break;
+		case CTelephony::EVoiceLineStatusChange:
+			SetRequestPending(CTelephonyFunctions::ENotifyVoiceLineStatus, EFalse);
+			break;
+		case CTelephony::EOwnedCall1StatusChange:
+			SetRequestPending(CTelephonyFunctions::ENotifyOwnedCall1Status, EFalse);
+			break;
+		case CTelephony::EOwnedCall2StatusChange:
+			SetRequestPending(CTelephonyFunctions::ENotifyOwnedCall2Status, EFalse);
+			break;
+		case CTelephony::EIndicatorChange:
+			SetRequestPending(CTelephonyFunctions::ENotifyIndicator, EFalse);
+			break;
+		case CTelephony::EPin1LockInfoChange:
+			SetRequestPending(CTelephonyFunctions::ENotifyPin1LockInfo, EFalse);
+			break;
+		case CTelephony::EPin2LockInfoChange:
+			SetRequestPending(CTelephonyFunctions::ENotifyPin2LockInfo, EFalse);
+			break;
+		case CTelephony::EBatteryInfoChange:
+			SetRequestPending(CTelephonyFunctions::ENotifyBatteryInfo, EFalse);
+			break;
+		case CTelephony::ESignalStrengthChange:
+			SetRequestPending(CTelephonyFunctions::ENotifySignalStrength, EFalse);
+			break;
+		case CTelephony::ENetworkRegistrationStatusChange:
+			SetRequestPending(CTelephonyFunctions::ENotifyNetworkRegistrationStatus, EFalse);
+			break;
+		case CTelephony::ECurrentNetworkInfoChange:
+			SetRequestPending(CTelephonyFunctions::ENotifyCurrentNetworkInfo, EFalse);
+			break;
+		default:
+			break;
+		}
+	}
+
+/**
+Completes the request back to the client that requested it.
+
+@param aOperation The operation that has been completed.
+@param aCompleteCode The error code to be returned to the client.
+*/
+void CTelephonyFunctions::CompleteRequest(TOperations aOperation, TInt aCompleteCode)
+	{
+	if(IsRequestPending(aOperation))
+		{
+		User::RequestComplete(*GetRequestStatus(aOperation), aCompleteCode);
+		SetRequestPending(aOperation, EFalse);
+		}
+
+	}
+
+CAsyncRequestBaseAct::CAsyncRequestBaseAct()
+	: CActive(CActive::EPriorityStandard)
+	{} //NOP
+
+CAsyncRequestBaseAct::~CAsyncRequestBaseAct()
+	{} //NOP
+
+void CAsyncRequestBaseAct::RunL()
+/**
+Service Completed request.
+
+@leave	Leaves if System error.
+*/
+	{
+	Complete();
+	}