diff -r 2473f5e227f9 -r 8b72faa1200f cbsref/telephonyrefplugins/atltsy/handler/src/cltsyphonehandler.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cbsref/telephonyrefplugins/atltsy/handler/src/cltsyphonehandler.cpp	Tue Jun 22 11:02:32 2010 +0100
@@ -0,0 +1,1218 @@
+// Copyright (c) 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:
+// CLtsyPhoneHandler
+
+#include <ctsy/ltsy/cctsydispatchercallback.h>
+#include <mmtsy_ipcdefs.h>
+#include <etelmm.h>
+#include <ctsy/ltsy/ltsylogger.h>
+#include <ctsy/ltsy/mltsydispatchphoneinterface.h>
+
+#include "cltsyphonehandler.h"
+#include "ltsymacros.h"
+#include "atgetmodemstatus.h"
+#include "atgetnetworkregistrationstatus.h"
+#include "atgetsimstatusready.h"
+#include "atgetnetworkinfo.h"
+#include "atgetsignalstrength.h"
+#include "atgetbatteryinfo.h"
+#include "atdetectnetwork.h"
+#include "getphoneid.h"
+#include "initializephone.h"
+#include "mslogger.h"
+#include "athangup.h"
+#include "getoperatorname.h"
+#include "atselectnetworkmode.h"
+#include "atselectnetwork.h"
+#include "atgetphonecellinfo.h"
+#include "atgetcellinfo.h"
+#include "atsetnotifycell.h"
+#include "asynchelperrequest.h"
+#include "atnetworkregstatuschange.h"
+#include "atnotifycellinfo.h"
+#include "notifybatteryandsignal.h"
+#include "getfdnstatus.h"
+#include "getcurrentnetworkinfo.h"
+#include "atgetphonecellinfo.h"
+
+CLtsyPhoneHandler::CLtsyPhoneHandler(
+	CCtsyDispatcherCallback& aCtsyDispatcherCallback,CGlobalPhonemanager* aGloblePhone)
+	: iCtsyDispatcherCallback(aCtsyDispatcherCallback),iGloblePhone(aGloblePhone)
+	{
+	}
+
+	
+CLtsyPhoneHandler::~CLtsyPhoneHandler()
+	{
+	if(iAsyncHelperRequest)
+		{
+		delete iAsyncHelperRequest;
+		iAsyncHelperRequest = NULL;
+		}	
+	if(iNetworkRegStatusChange)
+		{
+		delete iNetworkRegStatusChange;
+		iNetworkRegStatusChange = NULL;
+		}
+	if(iNotifyCellInfo)
+		{
+		delete iNotifyCellInfo;
+		iNotifyCellInfo = NULL;
+		}
+	if(iNotifyBatteryAndSignal)
+		{
+		delete iNotifyBatteryAndSignal;
+		iNotifyBatteryAndSignal = NULL;
+		}
+	if(iInitializePhone)
+		{
+		delete iInitializePhone;
+		iInitializePhone = NULL;
+		}
+	if(iATDetectNetwork)
+		{
+		delete iATDetectNetwork;
+		iATDetectNetwork = NULL;
+		}
+	}
+
+
+CLtsyPhoneHandler* CLtsyPhoneHandler::NewLC(
+	CCtsyDispatcherCallback& aCtsyDispatcherCallback,CGlobalPhonemanager* aGloblePhone)
+	{
+	TSYLOGENTRYEXIT;
+	CLtsyPhoneHandler* self = new (ELeave) CLtsyPhoneHandler(aCtsyDispatcherCallback,aGloblePhone);
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	return self;
+	}
+
+
+CLtsyPhoneHandler* CLtsyPhoneHandler::NewL(CCtsyDispatcherCallback& aCtsyDispatcherCallback,
+		CGlobalPhonemanager* aGloblePhone)
+	{
+	TSYLOGENTRYEXIT;
+	CLtsyPhoneHandler* self=
+			CLtsyPhoneHandler::NewLC(aCtsyDispatcherCallback,aGloblePhone);
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+
+void CLtsyPhoneHandler::ConstructL()
+/**
+ * Second phase constructor.
+ */
+	{
+	TSYLOGENTRYEXIT;
+	
+	//for temp
+	iNetworkRegStatusChange = CATNetworkRegStatusChange::NewL((*iGloblePhone), iCtsyDispatcherCallback);
+	iAsyncHelperRequest = CAsyncHelperRequest::NewL((*iGloblePhone), iCtsyDispatcherCallback);
+	iNotifyCellInfo = CATNotifyCellInfo::NewL((*iGloblePhone), iCtsyDispatcherCallback);
+	iNotifyBatteryAndSignal = CNotifyBatteryAndSignal::NewL((*iGloblePhone), iCtsyDispatcherCallback);
+	iInitializePhone = CInitializePhone::NewL(*iGloblePhone,
+			                                  iCtsyDispatcherCallback,
+			                                  *iNetworkRegStatusChange,
+			                                  *iNotifyBatteryAndSignal);
+	iATDetectNetwork  = CATDetectNetwork::NewL(*iGloblePhone,iCtsyDispatcherCallback);
+	iATSelectNetwork  = CATSelectNetwork::NewL(*iGloblePhone,iCtsyDispatcherCallback);
+	} // CLtsyPhoneHandler::ConstructL
+
+TBool CLtsyPhoneHandler::IsInterfaceSupported(TLtsyDispatchInterfaceApiId aDispatchApiId)
+/**
+ * Returns whether a Dispatch Interface APi is supported or not.
+ * 
+ * @param aDispatchApiId Id of Dispatch interface being queried
+ * @return indication whether interface is supported or not
+ */
+	{
+	switch(aDispatchApiId)
+		{
+		// Insert ApiIds when support is provided in LTSY e.g.
+		case KLtsyDispatchPhoneBootNotifyModemStatusReadyApiId: 
+			return ETrue;
+		case KLtsyDispatchPhoneBootNotifySimStatusReadyApiId: 
+			return ETrue;
+		case KLtsyDispatchPhoneGetFdnStatusApiId: 
+			return ETrue; 
+		case KLtsyDispatchPhoneGetHomeNetworkApiId: 
+			return ETrue;	
+		case KLtsyDispatchPhoneGetNetworkRegistrationStatusApiId: 
+			return ETrue;
+		case KLtsyDispatchPhoneSimRefreshRegisterApiId: 
+			return ETrue;
+		case KLtsyDispatchPhoneGetServiceProviderNameApiId: 
+			return ETrue; //Not finished
+		case KLtsyDispatchPhoneGetPhoneIdApiId: 
+			return ETrue;
+		case KLtsyDispatchPhoneGetDetectedNetworksApiId: 
+			return ETrue;
+		case KLtsyDispatchPhoneGetDetectedNetworksCancelApiId: 
+			return ETrue; //
+		case KLtsyDispatchPhoneSelectNetworkApiId: 
+			return ETrue;
+		case KLtsyDispatchPhoneSelectNetworkCancelApiId: 
+			return ETrue; //KErrNotSupported
+		case KLtsyDispatchPhoneSetNetworkSelectionSettingApiId: 
+			return ETrue;
+		case KLtsyDispatchPhoneGetCurrentNetworkInfoApiId: 
+			return ETrue; //Finished ?
+		case KLtsyDispatchPhoneGetNetworkModeApiId: 
+			return ETrue;
+		case KLtsyDispatchPhoneGetNitzInfoApiId: 
+			return ETrue; 
+		case KLtsyDispatchPhoneGetSignalStrengthApiId: 
+			return ETrue;
+		case KLtsyDispatchPhoneGetBatteryInfoApiId: 
+			return ETrue;
+		case KLtsyDispatchPhoneNspsWakeupApiId: 
+			return EFalse;
+		case KLtsyDispatchPhoneSetSystemNetworkModeApiId: 
+			return EFalse;
+		case KLtsyDispatchPhoneGetCurrentSystemNetworkModesApiId: 
+			return ETrue;
+		case KLtsyDispatchPhoneResetNetServerApiId: 
+			return EFalse;
+		case KLtsyDispatchPhoneSetAlwaysOnModeApiId: 
+			return EFalse;
+		case KLtsyDispatchPhoneSetDriveModeApiId: 
+			return EFalse;
+		case KLtsyDispatchPhoneGetHspaStatusApiId: 
+			return EFalse;
+		case KLtsyDispatchPhoneSetHspaStatusApiId: 
+			return EFalse;
+		case KLtsyDispatchPhoneGetNetworkProviderNameApiId: 
+			return ETrue;  
+		case KLtsyDispatchPhoneGetOperatorNameApiId: 
+			return ETrue;
+		case KLtsyDispatchPhoneGetCellInfoApiId: 
+			return ETrue;  
+		case KLtsyDispatchPhoneRegisterCellInfoChangeNotificationApiId: 
+			return ETrue;
+		case KLtsyDispatchPhoneGetPhoneCellInfoApiId: 
+			return ETrue;
+		case KLtsyDispatchPhoneGetUsimServiceSupportApiId: 
+			return EFalse;
+		case KLtsyDispatchPhoneGetCurrentActiveUsimApplicationApiId: 
+			return EFalse;
+		case KLtsyDispatchPhoneTerminateAllCallsApiId: 
+			return ETrue;
+		case KLtsyDispatchPhoneGetSystemNetworkBandApiId: 
+			return EFalse;
+		case KLtsyDispatchPhoneSetSystemNetworkBandApiId: 
+			return EFalse;
+		default:
+			return EFalse;
+		}
+	}
+
+void CLtsyPhoneHandler::IsCallbackIndicatorSupported(TLtsyDispatchIndIdGroup aIdGroup, TUint32& aIndIdBitMask)
+/**
+ * Returns the set of callback indicators that are supported.
+ * 
+* @param aIdGroup ID of group that is being queried e.g. aIdGroup=EIndIdGroup1.
+* @param aIndIdBitMask [out] argument that should return a bitmask indicating which indicator callbacks are supported.
+ */
+	{
+	//Create bitmask with bitset for each indicator ID that is supported. E.g.
+	if(aIdGroup == EIndIdGroup1)
+		aIndIdBitMask =   KLtsyDispatchPhoneNotifyNetworkModeChangeIndId |
+						  KLtsyDispatchPhoneNotifyEgprsInfoChangeIndId |
+						  KLtsyDispatchPhoneNotifySignalStrengthChangeIndId |
+						  KLtsyDispatchPhoneNotifyNetworkRegistrationStatusChangeIndId |
+						  KLtsyDispatchPhoneNotifyNitzInfoChangeIndId |
+						  KLtsyDispatchPhoneNotifyBatteryInfoChangeIndId |
+						  KLtsyDispatchPhoneNotifyCurrentNetworkChangeIndId |
+						  KLtsyDispatchPhoneNotifyRfStatusChangeIndId |
+						  KLtsyDispatchPhoneNotifyCellInfoChangeIndId ;
+	else
+		aIndIdBitMask = 0; //no indicators from other groups supported
+	
+	}
+
+TInt CLtsyPhoneHandler::HandleGetFdnStatusReqL()
+/**
+ * This request is completed by invoking
+ * CCtsyDispatcherCallback::CallbackPhoneGetFdnStatusComp()
+ *
+ * @return KErrNone on success, KErrNotSupported if this request is not supported,
+ * or another error code to indicate the failure otherwise.
+ */
+	{
+	TSYLOGENTRYEXIT;
+	TInt ret = KErrNotSupported;
+	ret = iGloblePhone->CheckGlobalPhoneStatus();
+	if(ret == KErrNone)
+		{
+		CGetFdnStatus* GetFdnStatus  = CGetFdnStatus::NewL(*iGloblePhone,iCtsyDispatcherCallback);
+		iGloblePhone->iEventSignalActive = ETrue;
+		iGloblePhone->SetActiveRequest(GetFdnStatus);
+		GetFdnStatus->StartRequest();
+		}
+	return TSYLOGSETEXITERR(ret);
+	} // CLtsyPhoneHandler::HandleGetFdnStatusReqL
+
+
+TInt CLtsyPhoneHandler::HandleGetNetworkRegistrationStatusReqL()
+/**
+ * This request is completed by invoking
+ * CCtsyDispatcherCallback::CallbackPhoneGetNetworkRegistrationStatusComp()
+ *
+ * @return KErrNone on success, KErrNotSupported if this request is not supported,
+ * or another error code to indicate the failure otherwise.
+ */
+	{
+	TSYLOGENTRYEXIT;
+	TInt ret = KErrNone;
+	ret = iGloblePhone->CheckGlobalPhoneStatus();
+	if(ret == EPhoneInitialising)
+		{
+		iInitializePhone->AppendIpcRequestToPendingListL(KLtsyDispatchPhoneGetNetworkRegistrationStatusApiId);
+		iInitializePhone->ExecutePendingRequest();   
+		ret = KErrNone;
+		}
+	else if(ret == KErrNone)
+		{
+		CATNetworkRegistration* atNetworkRegStatus  = CATNetworkRegistration::NewL(*iGloblePhone,
+				                                                                   iCtsyDispatcherCallback);
+		iGloblePhone->iEventSignalActive = ETrue;
+		iGloblePhone->SetActiveRequest(atNetworkRegStatus);
+		atNetworkRegStatus->SetIpcRequestCompleteObserver(this);
+		atNetworkRegStatus->SetIpcId(KLtsyDispatchPhoneGetNetworkRegistrationStatusApiId);
+		iNetworkRegStatusChange->Disable();
+		atNetworkRegStatus->StartRequest();
+		}
+	 
+	return TSYLOGSETEXITERR(ret);
+	} // CLtsyPhoneHandler::HandleGetNetworkRegistrationStatusReqL
+
+
+TInt CLtsyPhoneHandler::HandleGetHomeNetworkReqL()
+/**
+ * This request is completed by invoking
+ * CCtsyDispatcherCallback::CallbackPhoneGetHomeNetworkComp()
+ *
+ * @return KErrNone on success, KErrNotSupported if this request is not supported,
+ * or another error code to indicate the failure otherwise. 
+ */
+	{
+	TSYLOGENTRYEXIT;
+	TInt ret = KErrNotSupported;
+	ret = iGloblePhone->CheckGlobalPhoneStatus();
+	if(ret == EPhoneInitialising)
+		{
+		iInitializePhone->AppendIpcRequestToPendingListL(KLtsyDispatchPhoneGetHomeNetworkApiId);
+        iInitializePhone->ExecutePendingRequest();   
+		ret = KErrNone;
+		}
+	else if(ret == KErrNone)
+		{
+		CATNetworkInfo* ATNetworkInfo  = CATNetworkInfo::NewL(*iGloblePhone,iCtsyDispatcherCallback);
+		iGloblePhone->iEventSignalActive = ETrue;
+		iGloblePhone->SetActiveRequest(ATNetworkInfo);
+		ATNetworkInfo->SetToGetHomeNwk();
+		ATNetworkInfo->StartRequest();
+		}
+	return TSYLOGSETEXITERR(ret);
+	} // CLtsyPhoneHandler::HandleGetHomeNetworkReqL
+
+
+TInt CLtsyPhoneHandler::HandleBootNotifyModemStatusReadyReqL()
+/**
+ * This request is completed by invoking
+ * CCtsyDispatcherCallback::CallbackPhoneBootNotifyModemStatusReadyComp()
+ *
+ * @return KErrNone on success, KErrNotSupported if this request is not supported,
+ * or another error code to indicate the failure otherwise. 
+ */
+	{
+	TSYLOGENTRYEXIT;
+    // This function is the entry of phone bootup
+	// Let's get the phone bootup
+	TInt ret = KErrNone;
+	ret = iGloblePhone->CheckGlobalPhoneStatus();
+	if(ret == EPhoneNotInitialised)
+		{
+		iGloblePhone->iPhoneStatus.iInitStatus = EPhoneInitialising;
+		iGloblePhone->iEventSignalActive = ETrue;
+		iInitializePhone->StartRequest();
+		ret = KErrNone;
+		}
+	else if(ret == KErrNone)
+		{
+		CATGetModemStatus* ATGetModemStatus = CATGetModemStatus::NewL(*iGloblePhone,iCtsyDispatcherCallback);
+		iGloblePhone->iEventSignalActive = ETrue;
+		iGloblePhone->SetActiveRequest(ATGetModemStatus);
+		ATGetModemStatus->StartRequest();
+		}	
+	return TSYLOGSETEXITERR(ret);
+	} // CLtsyPhoneHandler::HandleBootNotifyModemStatusReadyReqL
+
+
+TInt CLtsyPhoneHandler::HandleBootNotifySimStatusReadyReqL()
+/**
+ * This request is completed by invoking
+ * CCtsyDispatcherCallback::CallbackPhoneBootNotifySimStatusReadyComp()
+ * 
+ * @return KErrNone on success, KErrNotSupported if this request is not supported,
+ * or another error code to indicate the failure otherwise. 
+ */
+	{
+	TSYLOGENTRYEXIT;
+	
+	TInt ret = KErrNone;
+	ret = iGloblePhone->CheckGlobalPhoneStatus();
+	if(ret == EPhoneInitialising)
+		{
+		iInitializePhone->AppendIpcRequestToPendingListL(KLtsyDispatchPhoneBootNotifySimStatusReadyApiId);
+        iInitializePhone->ExecutePendingRequest();   
+		ret = KErrNone;
+		}
+	else if(ret == KErrNone)
+		{
+		CATSIMCard* ATSIMCard  = CATSIMCard::NewL(*iGloblePhone,iCtsyDispatcherCallback);
+		iGloblePhone->iEventSignalActive = ETrue;
+		iGloblePhone->SetActiveRequest(ATSIMCard);
+		ATSIMCard->StartRequest();
+		}
+
+	return TSYLOGSETEXITERR(ret);
+	} // CLtsyPhoneHandler::HandleBootNotifySimStatusReadyReqL
+
+TInt CLtsyPhoneHandler::HandleSimRefreshRegisterReqL(TUint16 /*aFilesToRegister*/)
+/**
+ * @param aFilesToRegister  Bitmask containing list of files to register for refresh indications.
+ * The list of possible files is specified in TCacheFileTypes.
+ * 
+ * @return KErrNone on success, KErrNotSupported if this request is not supported,
+ * or another error code to indicate the failure otherwise. 
+ */
+	{
+	TSYLOGENTRYEXIT;
+	
+	TInt ret = KErrNotSupported;
+	ret = iGloblePhone->CheckGlobalPhoneStatus();
+	if(ret == EPhoneInitialising)
+		{
+		iInitializePhone->AppendIpcRequestToPendingListL(KLtsyDispatchPhoneSimRefreshRegisterApiId);
+        iInitializePhone->ExecutePendingRequest();   
+        ret = KErrNone;
+		}
+	else if(ret == EPhoneInitialised)
+		{
+		iAsyncHelperRequest->SetRequestId(KLtsyDispatchPhoneSimRefreshRegisterApiId);
+		}
+	return TSYLOGSETEXITERR(ret);
+	} // CLtsyPhoneHandler::HandleSimRefreshRegisterReqL
+
+TInt CLtsyPhoneHandler::HandleGetServiceProviderNameReqL()
+/**
+ * This request is completed by invoking
+ * CCtsyDispatcherCallback::CallbackPhoneGetServiceProviderNameComp()
+ *
+ = * @return KErrNone on success, KErrNotSupported if this request is not supported,
+ * or another error code to indicate the failure otherwise.
+ */
+	{
+	TSYLOGENTRYEXIT;
+
+	//TInt ret = KErrNotSupported;
+	TInt ret = 0;
+	ret = iGloblePhone->CheckGlobalPhoneStatus();
+	if(ret == KErrNone)
+		{
+		CGetOperatorNmae* GetOperatorName  = CGetOperatorNmae::NewL(*iGloblePhone,iCtsyDispatcherCallback);
+		iGloblePhone->iEventSignalActive = ETrue;
+		GetOperatorName->SetRequestTypeL(KLtsyDispatchPhoneGetServiceProviderNameApiId);
+		iGloblePhone->SetActiveRequest(GetOperatorName);
+		GetOperatorName->StartRequest();
+		}
+
+	return TSYLOGSETEXITERR(ret);
+	} // CLtsyPhoneHandler::HandleGetServiceProviderNameReqL
+
+
+TInt CLtsyPhoneHandler::HandleGetPhoneIdReqL()
+/**
+ * This request is completed by invoking
+ * CCtsyDispatcherCallback::CallbackPhoneGetPhoneIdComp()
+ *
+ * @return KErrNone on success, KErrNotSupported if this request is not supported,
+ * or another error code to indicate the failure otherwise.
+ */
+	{
+	TSYLOGENTRYEXIT;
+
+	//TInt ret = KErrNotSupported;
+	TInt ret = KErrNone;
+	ret = iGloblePhone->CheckGlobalPhoneStatus();
+	if(ret == KErrNone)
+		{
+		CGetPhoneID* GetPhoneID  = CGetPhoneID::NewL(*iGloblePhone,iCtsyDispatcherCallback);
+		iGloblePhone->iEventSignalActive = ETrue;
+		iGloblePhone->SetActiveRequest(GetPhoneID);
+		GetPhoneID->StartRequest();
+		}
+	return TSYLOGSETEXITERR(ret);
+	} // CLtsyPhoneHandler::HandleGetPhoneIdReqL
+
+
+TInt CLtsyPhoneHandler::HandleGetDetectedNetworksReqL()
+/**
+ * This request is completed by invoking
+ * CCtsyDispatcherCallback::CallbackPhoneGetDetectedNetworksComp()
+ *
+ * @return KErrNone on success, KErrNotSupported if this request is not supported,
+ * or another error code to indicate the failure otherwise.
+ */
+	{
+	TSYLOGENTRYEXIT;
+
+	//TInt ret = KErrNotSupported;
+	TInt ret = 0;
+	
+	ret = KErrNone;
+	ret = iGloblePhone->CheckGlobalPhoneStatus();
+	if(ret == KErrNone)
+		{
+		iGloblePhone->iEventSignalActive = ETrue;
+		iATDetectNetwork->StartRequest();
+		}
+	
+	return TSYLOGSETEXITERR(ret);
+	
+	} // CLtsyPhoneHandler::HandleGetDetectedNetworksReqL
+
+
+TInt CLtsyPhoneHandler::HandleGetDetectedNetworksCancelReqL()
+/**
+ * This request is completed by invoking
+ * CCtsyDispatcherCallback::CallbackPhoneGetDetectedNetworksCancelComp()
+ *
+ * @return KErrNone on success, KErrNotSupported if this request is not supported,
+ * or another error code to indicate the failure otherwise.
+ */
+	{
+	TSYLOGENTRYEXIT;
+
+	//TInt ret = KErrNotSupported;
+	TInt ret = 0;
+	ret = iGloblePhone->CheckGlobalPhoneStatus();
+	if((ret == KErrInUse)&&(iATDetectNetwork->iCommandRunning))
+		{
+		if(iATDetectNetwork->iCommandCancel)
+			{
+			ret = KErrNotSupported;
+			}
+		else
+			{
+		    iATDetectNetwork->CancelCommand();
+		    ret = KErrNone;
+			}
+		}
+	else if(ret == KErrNone)
+		{
+		iAsyncHelperRequest->SetRequestId(KLtsyDispatchPhoneGetDetectedNetworksCancelApiId);
+		}
+	return TSYLOGSETEXITERR(ret);
+	} // CLtsyPhoneHandler::HandleGetDetectedNetworksCancelReqL
+
+
+TInt CLtsyPhoneHandler::HandleSelectNetworkReqL(TBool aIsManual, const RMobilePhone::TMobilePhoneNetworkManualSelection& aNetworkManualSelection)
+/**
+ * This request is completed by invoking
+ * CCtsyDispatcherCallback::CallbackPhoneSelectNetworkComp()
+ *
+ * @param aIsManual Specifies whether phone should use a manual or automatic network selection method.
+ * @param aNetworkManualSelection If aIsManual==ETrue, then this parameter contain the user's manually selected network.
+ *
+ * @return KErrNone on success, KErrNotSupported if this request is not supported,
+ * or another error code to indicate the failure otherwise.
+ */
+	{
+	TSYLOGENTRYEXIT;
+	TInt ret = KErrNotSupported;
+	if(!aIsManual)
+		{
+		return KErrNotSupported;
+		}
+	ret = iGloblePhone->CheckGlobalPhoneStatus();
+	if(ret == KErrNone)
+		{
+		iGloblePhone->iEventSignalActive = ETrue;
+		iATSelectNetwork->SetNetworkSelection(aNetworkManualSelection);
+		iATSelectNetwork->StartRequest();
+		}
+
+	return TSYLOGSETEXITERR(ret);
+	} // CLtsyPhoneHandler::HandleSelectNetworkReqL
+
+
+TInt CLtsyPhoneHandler::HandleSelectNetworkCancelReqL()
+/**
+ * This request is completed by invoking
+ * CCtsyDispatcherCallback::CallbackPhoneSelectNetworkCancelComp()
+ *
+ *
+ * @return KErrNone on success, KErrNotSupported if this request is not supported,
+ * or another error code to indicate the failure otherwise.
+ */
+	{
+	TSYLOGENTRYEXIT;
+	TInt ret = 0;
+	ret = iGloblePhone->CheckGlobalPhoneStatus();
+	if((ret == KErrInUse)&&(iATSelectNetwork->iCommandRunning))
+		{
+		if(iATSelectNetwork->iCommandCancel)
+			{
+			ret = KErrNotSupported;
+			}
+		else
+			{
+			iATSelectNetwork->CancelCommand();
+		    ret = KErrNone;
+			}
+		}
+	else if(ret == KErrNone)
+		{
+		iAsyncHelperRequest->SetRequestId(KLtsyDispatchPhoneSelectNetworkCancelApiId);
+		}
+	return TSYLOGSETEXITERR(ret);
+	} // CLtsyPhoneHandler::HandleSelectNetworkCancelReqL
+
+
+TInt CLtsyPhoneHandler::HandleSetNetworkSelectionSettingReqL(const RMobilePhone::TMobilePhoneNetworkSelectionV1& aPhoneNetworkSelection)
+/**
+ * This request is completed by invoking
+ * CCtsyDispatcherCallback::CallbackPhoneSetNetworkSelectionSettingComp()
+ *
+ * @param aPhoneNetworkSelection The network selection to be set.
+ *
+ * @return KErrNone on success, KErrNotSupported if this request is not supported,
+ * or another error code to indicate the failure otherwise.
+ */
+	{
+	TSYLOGENTRYEXIT;
+
+	TInt ret = KErrNotSupported;
+	TInt networkSelection = -1;
+	switch (aPhoneNetworkSelection.iMethod)
+		{
+	case RMobilePhone::ENetworkSelectionAutomatic:
+	    networkSelection = 0;
+		break;
+	case RMobilePhone::ENetworkSelectionManual:
+	    networkSelection = 1;
+		break;
+	default:
+	    networkSelection = 0;
+		break;
+		}
+	
+	if(networkSelection != -1)
+		{
+		ret = iGloblePhone->CheckGlobalPhoneStatus();
+		if(ret == KErrNone)
+			{
+			CATSelectNetworkMode* ATSelectNetworkMode  = CATSelectNetworkMode::NewL(*iGloblePhone,iCtsyDispatcherCallback);
+			iGloblePhone->iEventSignalActive = ETrue;
+			iGloblePhone->SetActiveRequest(ATSelectNetworkMode);
+			ATSelectNetworkMode->SetNetworkSelection(networkSelection);
+			ATSelectNetworkMode->StartRequest();
+			ret = KErrNone;
+			}
+		}
+
+	return TSYLOGSETEXITERR(ret);
+	} // CLtsyPhoneHandler::HandleSetNetworkSelectionSettingReqL
+
+
+TInt CLtsyPhoneHandler::HandleGetCurrentNetworkInfoReqL()
+/**
+ * This request is completed by invoking
+ * CCtsyDispatcherCallback::CallbackPhoneGetCurrentNetworkInfoComp()
+ *
+ * @return KErrNone on success, KErrNotSupported if this request is not supported,
+ * or another error code to indicate the failure otherwise.
+ */
+	{
+	TSYLOGENTRYEXIT;
+
+	TInt ret = KErrNone;
+	ret = iGloblePhone->CheckGlobalPhoneStatus();
+	if(ret == EPhoneInitialising)
+		{
+		iInitializePhone->AppendIpcRequestToPendingListL(KLtsyDispatchPhoneGetCurrentNetworkInfoApiId);
+        iInitializePhone->ExecutePendingRequest();   
+		ret = KErrNone;
+		}
+	else if(ret == KErrNone)
+		{
+		CGetCurrentNetworkInfo* ATNetworkInfo  = CGetCurrentNetworkInfo::NewL(*iGloblePhone,iCtsyDispatcherCallback);
+		iGloblePhone->iEventSignalActive = ETrue;
+		iGloblePhone->SetActiveRequest(ATNetworkInfo);
+		ATNetworkInfo->StartRequest();
+		}
+	return TSYLOGSETEXITERR(ret);
+	} // CLtsyPhoneHandler::HandleGetCurrentNetworkInfoReqL
+
+
+TInt CLtsyPhoneHandler::HandleGetNetworkModeReqL()
+/**
+ * This request is completed by invoking
+ * CCtsyDispatcherCallback::CallbackPhoneGetNetworkModeComp()
+ *
+ * @return KErrNone on success, KErrNotSupported if this request is not supported,
+ * or another error code to indicate the failure otherwise.
+ */
+	{
+	TSYLOGENTRYEXIT;
+
+	TInt ret = KErrNotSupported;
+	ret = iGloblePhone->CheckGlobalPhoneStatus();
+	if(ret == EPhoneInitialising)
+		{
+		iInitializePhone->AppendIpcRequestToPendingListL(KLtsyDispatchPhoneGetNetworkModeApiId);
+        iInitializePhone->ExecutePendingRequest();   	
+		ret = KErrNone;
+		}
+	else if(ret == EPhoneInitialised)
+		{
+		iAsyncHelperRequest->SetRequestId(KLtsyDispatchPhoneGetNetworkModeApiId);
+		}
+	return TSYLOGSETEXITERR(ret);
+	} // CLtsyPhoneHandler::HandleGetNetworkModeReqL
+
+
+TInt CLtsyPhoneHandler::HandleGetNitzInfoReqL()
+/**
+ * This request is completed by invoking
+ * CCtsyDispatcherCallback::CallbackPhoneGetNitzInfoComp()
+ *
+ * @return KErrNone on success, KErrNotSupported if this request is not supported,
+ * or another error code to indicate the failure otherwise.
+ */
+	{
+	TSYLOGENTRYEXIT;
+	TInt ret = KErrNotSupported;
+	ret = iGloblePhone->CheckGlobalPhoneStatus();
+	if(ret == EPhoneInitialising)
+		{
+		iInitializePhone->AppendIpcRequestToPendingListL(KLtsyDispatchPhoneGetNitzInfoApiId);
+        iInitializePhone->ExecutePendingRequest();   
+		ret = KErrNone;
+		}
+	else if(ret == EPhoneInitialised)
+		{
+		iAsyncHelperRequest->SetRequestId(KLtsyDispatchPhoneGetNitzInfoApiId);
+		}
+	return TSYLOGSETEXITERR(ret);
+	} // CLtsyPhoneHandler::HandleGetNITZInfoReqL()
+
+
+TInt CLtsyPhoneHandler::HandleGetSignalStrengthReqL()
+/**
+ * This request is completed by invoking
+ * CCtsyDispatcherCallback::CallbackPhoneGetSignalStrengthComp()
+ *
+ * @return KErrNone on success, KErrNotSupported if this request is not supported,
+ * or another error code to indicate the failure otherwise.
+ */
+	{
+	TSYLOGENTRYEXIT;
+
+	TInt ret = KErrNone;
+	ret = iGloblePhone->CheckGlobalPhoneStatus();
+	if(ret == EPhoneInitialising)
+		{
+		iInitializePhone->AppendIpcRequestToPendingListL(KLtsyDispatchPhoneGetSignalStrengthApiId);
+        iInitializePhone->ExecutePendingRequest();   
+		ret = KErrNone;
+		}
+	else if(ret == KErrNone)
+		{
+		CATGetSignal* ATGetSignal  = CATGetSignal::NewL(*iGloblePhone,iCtsyDispatcherCallback);
+		iGloblePhone->iEventSignalActive = ETrue;
+		iGloblePhone->SetActiveRequest(ATGetSignal);
+		ATGetSignal->StartRequest();
+		}
+	return TSYLOGSETEXITERR(ret);
+	} // CLtsyPhoneHandler::HandleGetSignalStrengthReqL()
+
+
+TInt CLtsyPhoneHandler::HandleGetBatteryInfoReqL()
+/**
+ * This request is completed by invoking
+ * CCtsyDispatcherCallback::CallbackPhoneGetBatteryInfoComp()
+ *
+ * @return KErrNone on success, KErrNotSupported if this request is not supported,
+ * or another error code to indicate the failure otherwise.
+ */
+	{
+	TSYLOGENTRYEXIT;
+
+	TInt ret = KErrNone;
+	ret = iGloblePhone->CheckGlobalPhoneStatus();
+	if(ret == EPhoneInitialising)
+		{
+		iInitializePhone->AppendIpcRequestToPendingListL(KLtsyDispatchPhoneGetBatteryInfoApiId);
+        iInitializePhone->ExecutePendingRequest();   
+		ret = KErrNone;
+		}
+	else if(ret == KErrNone)
+		{
+		CATGetBattery* ATGetBattery  = CATGetBattery::NewL(*iGloblePhone,iCtsyDispatcherCallback);
+		iGloblePhone->iEventSignalActive = ETrue;
+		iGloblePhone->SetActiveRequest(ATGetBattery);
+		ATGetBattery->StartRequest();
+		}
+	
+	return TSYLOGSETEXITERR(ret);
+	} // CLtsyPhoneHandler::HandleGetBatteryInfoReqL
+
+
+TInt CLtsyPhoneHandler::HandleNspsWakeupReqL()
+/**
+ * This request is completed by invoking
+ * CCtsyDispatcherCallback::CallbackPhoneNspsWakeupComp()
+ *
+ * @return KErrNone on success, KErrNotSupported if this request is not supported,
+ * or another error code to indicate the failure otherwise. 
+ */
+	{
+	TSYLOGENTRYEXIT;
+
+	TInt ret = KErrNotSupported;
+	return TSYLOGSETEXITERR(ret);
+	} // CLtsyPhoneHandler::HandleNspsWakeupReqL
+
+
+TInt CLtsyPhoneHandler::HandleSetSystemNetworkModeReqL(RMmCustomAPI::TNetworkModeCaps /*aMode*/)
+/**
+ * This request is completed by invoking
+ * CCtsyDispatcherCallback::CallbackPhoneSetSystemNetworkModeComp()
+ *
+ * @param aMode Specifies the mode to set the system network to.
+ *
+ * @return KErrNone on success, KErrNotSupported if this request is not supported,
+ * or another error code to indicate the failure otherwise. 
+ */
+	{
+	TSYLOGENTRYEXIT;
+
+	TInt ret = KErrNotSupported;
+	return TSYLOGSETEXITERR(ret);
+	} // CLtsyPhoneHandler::HandleSetSystemNetworkModeReqL
+
+
+TInt CLtsyPhoneHandler::HandleGetCurrentSystemNetworkModesReqL()
+/**
+ * This request is completed by invoking
+ * CCtsyDispatcherCallback::CallbackPhoneGetCurrentSystemNetworkModesComp()
+ *
+ * @return KErrNone on success, KErrNotSupported if this request is not supported,
+ * or another error code to indicate the failure otherwise. 
+ */
+	{
+	TSYLOGENTRYEXIT;
+
+	TInt ret = 0;
+	iAsyncHelperRequest->SetRequestId(KLtsyDispatchPhoneGetCurrentSystemNetworkModesApiId);
+	return TSYLOGSETEXITERR(ret);
+	} // CLtsyPhoneHandler::HandleGetCurrentSystemNetworkModesReqL
+
+
+TInt CLtsyPhoneHandler::HandleResetNetServerReqL()
+/**
+ * This request is completed by invoking
+ * CCtsyDispatcherCallback::CallbackPhoneResetNetServerComp()
+ *
+ * @return KErrNone on success, KErrNotSupported if this request is not supported,
+ * or another error code to indicate the failure otherwise. 
+ */
+	{
+	TSYLOGENTRYEXIT;
+
+	TInt ret = KErrNotSupported;
+	return TSYLOGSETEXITERR(ret);
+	} // CLtsyPhoneHandler::HandleResetNetServerReqL
+
+
+TInt CLtsyPhoneHandler::HandleSetAlwaysOnModeReqL(RMmCustomAPI::TSetAlwaysOnMode /*aMode*/)
+/**
+ * This request is completed by invoking
+ * CCtsyDispatcherCallback::CallbackPhoneSetAlwaysOnModeComp()
+ *
+ * @param aMode The new "always on" mode to set, can be
+ *               RMmCustomAPI::EAlwaysModeVPLMN for VPLMN (Visited Public Land Mobile Network) always on,
+ *               RMmCustomAPI::EAlwaysModeHPLMN for HPLMN (Home Public Land Mobile Network) always on,
+ *               RMmCustomAPI::EAlwaysModeBoth for VPLMN and HPLMN always on,
+ *               RMmCustomAPI::EAlwaysModeNeither for neither VPLMN mor HPLMN always on.
+ *
+ * @return KErrNone on success, KErrNotSupported if this request is not supported,
+ * or another error code to indicate the failure otherwise. 
+ */
+	{
+	TSYLOGENTRYEXIT;
+
+	TInt ret = KErrNotSupported;
+	return TSYLOGSETEXITERR(ret);
+	} // CLtsyPhoneHandler::HandleSetAlwaysOnModeReqL
+
+
+TInt CLtsyPhoneHandler::HandleSetDriveModeReqL(RMmCustomAPI::TSetDriveMode /*aMode*/)
+/**
+ * This request is completed by invoking
+ * CCtsyDispatcherCallback::CallbackPhoneSetDriveModeComp()
+ *
+ * @param aMode The new mode to set (RMmCustomAPI::EDeactivateDriveMode for deactivate drive mode
+ *               or RMmCustomAPI::EActivateDriveMode to activate drive mode).
+ *
+ *
+ * @return KErrNone on success, KErrNotSupported if this request is not supported,
+ * or another error code to indicate the failure otherwise. 
+ */
+	{
+	TSYLOGENTRYEXIT;
+
+	TInt ret = KErrNotSupported;
+	return TSYLOGSETEXITERR(ret);
+	} // CLtsyPhoneHandler::HandleSetDriveModeReqL
+
+
+TInt CLtsyPhoneHandler::HandleGetHspaStatusReqL()
+/**
+ * This request is completed by invoking
+ * CCtsyDispatcherCallback::CallbackPhoneGetHspaStatusComp()
+ *
+ * @return KErrNone on success, KErrNotSupported if this request is not supported,
+ * or another error code to indicate the failure otherwise. 
+ */
+	{
+	TSYLOGENTRYEXIT;
+
+	TInt ret = KErrNotSupported;
+	return TSYLOGSETEXITERR(ret);
+	} // CLtsyPhoneHandler::HandleGetHspaStatusReqL
+
+
+TInt CLtsyPhoneHandler::HandleSetHspaStatusReqL(RMmCustomAPI::THSxPAStatus /*aStatus*/)
+/**
+ * This request is completed by invoking
+ * CCtsyDispatcherCallback::CallbackPhoneSetHspaStatusComp()
+ *
+ * @param aStatus The new HSxPA status (enable or disable).
+ *
+ * @return KErrNone on success, KErrNotSupported if this request is not supported,
+ * or another error code to indicate the failure otherwise. 
+ */
+	{
+	TSYLOGENTRYEXIT;
+
+	TInt ret = KErrNotSupported;
+	return TSYLOGSETEXITERR(ret);
+	} // CLtsyPhoneHandler::HandleSetHspaStatusReqL
+
+
+TInt CLtsyPhoneHandler::HandleGetNetworkProviderNameReqL()
+/**
+ * This request is completed by invoking
+ * CCtsyDispatcherCallback::CallbackPhoneGetNetworkProviderNameComp()
+ *
+ * @return KErrNone on success, KErrNotSupported if this request is not supported,
+ * or another error code to indicate the failure otherwise. 
+ */
+	{
+	TSYLOGENTRYEXIT;
+
+	TInt ret = KErrNotSupported;
+	ret = iGloblePhone->CheckGlobalPhoneStatus();
+	if(ret == KErrNone)
+		{
+		CGetOperatorNmae* GetOperatorName  = CGetOperatorNmae::NewL(*iGloblePhone,iCtsyDispatcherCallback);
+		iGloblePhone->iEventSignalActive = ETrue;
+		GetOperatorName->SetRequestTypeL(KLtsyDispatchPhoneGetNetworkProviderNameApiId);
+		iGloblePhone->SetActiveRequest(GetOperatorName);
+		GetOperatorName->StartRequest();
+		}
+	return TSYLOGSETEXITERR(ret);
+	} // CLtsyPhoneHandler::HandleGetNetworkProviderNameReqL
+
+
+TInt CLtsyPhoneHandler::HandleGetOperatorNameReqL()
+/**
+ * This request is completed by invoking
+ * CCtsyDispatcherCallback::CallbackPhoneGetOperatorNameComp()
+ *
+ * @return KErrNone on success, KErrNotSupported if this request is not supported,
+ * or another error code to indicate the failure otherwise. 
+ */
+	{
+	TSYLOGENTRYEXIT;
+
+	TInt ret = KErrNotSupported;
+	ret = iGloblePhone->CheckGlobalPhoneStatus();
+	if(ret == KErrNone)
+		{
+		CGetOperatorNmae* GetOperatorName  = CGetOperatorNmae::NewL(*iGloblePhone,iCtsyDispatcherCallback);
+		iGloblePhone->iEventSignalActive = ETrue;
+		GetOperatorName->SetRequestTypeL(KLtsyDispatchPhoneGetOperatorNameApiId);
+		iGloblePhone->SetActiveRequest(GetOperatorName);
+		GetOperatorName->StartRequest();
+		}
+
+	return TSYLOGSETEXITERR(ret);
+	} // CLtsyPhoneHandler::HandleGetOperatorNameReqL
+
+
+TInt CLtsyPhoneHandler::HandleGetCellInfoReqL()
+/**
+ * This request is completed by invoking one of the 
+ * CCtsyDispatcherCallback::CallbackPhoneGetCellInfoComp().
+ *
+ * @return KErrNone on success, KErrNotSupported if this request is not supported,
+ * or another error code to indicate the failure otherwise. 
+ */
+	{
+	TSYLOGENTRYEXIT;
+
+	TInt ret = KErrNotSupported;
+	ret = iGloblePhone->CheckGlobalPhoneStatus();
+	if(ret == KErrNone)
+		{
+		CATGetCellInfo* atGetCellInfo  = CATGetCellInfo::NewL(*iGloblePhone,
+				                                              iCtsyDispatcherCallback);
+		iGloblePhone->iEventSignalActive = ETrue;
+		iGloblePhone->SetActiveRequest(atGetCellInfo);
+		atGetCellInfo->SetIpcId(KLtsyDispatchPhoneGetCellInfoApiId);
+		atGetCellInfo->SetIpcRequestCompleteObserver(this);
+		iNotifyCellInfo->Disable();
+		atGetCellInfo->StartRequest();
+		}
+	return TSYLOGSETEXITERR(ret);
+	} // CLtsyPhoneHandler::HandleGetCellInfoReqL
+
+TInt CLtsyPhoneHandler::HandleRegisterCellInfoChangeNotificationReqL()
+/**
+ * This request is completed by invoking
+ * CCtsyDispatcherCallback::CallbackPhoneRegisterCellInfoChangeNotificationComp()
+ *
+ * @return KErrNone on success, KErrNotSupported if this request is not supported,
+ * or another error code to indicate the failure otherwise.
+ */
+	{
+	TSYLOGENTRYEXIT;
+
+	//TInt ret = KErrNotSupported;
+	TInt ret = KErrNone;
+	ret = iGloblePhone->CheckGlobalPhoneStatus();
+	if(ret == KErrNone)
+		{
+		CATSetNotifyCellInfo* atSetNotifyCellInfo  = CATSetNotifyCellInfo::NewL(*iGloblePhone,
+				                                                                iCtsyDispatcherCallback);
+		iGloblePhone->iEventSignalActive = ETrue;
+		iGloblePhone->SetActiveRequest(atSetNotifyCellInfo);
+		atSetNotifyCellInfo->SetIpcId(KLtsyDispatchPhoneRegisterCellInfoChangeNotificationApiId);
+		atSetNotifyCellInfo->SetIpcRequestCompleteObserver(this);
+		atSetNotifyCellInfo->StartRequest();
+		}
+	return TSYLOGSETEXITERR(ret);
+	} // CLtsyPhoneHandler::HandleRegisterCellInfoChangeNotificationReqL 
+
+TInt CLtsyPhoneHandler::HandleGetPhoneCellInfoReqL()
+/**
+ * This request is completed by invoking
+ * CCtsyDispatcherCallback::CallbackPhoneGetPhoneCellInfoComp()
+ *
+ * @return KErrNone on success, KErrNotSupported if this request is not supported,
+ * or another error code to indicate the failure otherwise.
+ */
+	{
+	TSYLOGENTRYEXIT;
+
+	TInt ret = KErrNotSupported;
+	ret = iGloblePhone->CheckGlobalPhoneStatus();
+	if(ret == KErrNone)
+		{
+		CATGetPhoneCellInfo* atGetPhoneCellInfo  = CATGetPhoneCellInfo::NewL(*iGloblePhone,
+				                                                             iCtsyDispatcherCallback);
+		iGloblePhone->iEventSignalActive = ETrue;
+		iGloblePhone->SetActiveRequest(atGetPhoneCellInfo);
+		atGetPhoneCellInfo->SetIpcRequestCompleteObserver(this);
+		atGetPhoneCellInfo->SetIpcId(KLtsyDispatchPhoneGetPhoneCellInfoApiId);
+		// disable to get the notification as we may get the incorrect response after CATGetPhoneCellInfo command was issued
+		iNotifyCellInfo->Disable();
+		atGetPhoneCellInfo->StartRequest();
+		}
+	else if (ret == KErrInUse)
+		{
+		// as dispather will post two IPC requests(KLtsyDispatchPhoneRegisterCellInfoChangeNotificationApiId and KLtsyDispatchPhoneGetPhoneCellInfoApiId)
+		// together, so we need store one and then execute this AT command after previous one was complete
+		iPendingIpcId = KLtsyDispatchPhoneGetPhoneCellInfoApiId;
+		CRequestBase* activeReq = iGloblePhone->CurrentActiveRequest();
+		if(activeReq)
+		    {
+		    if(activeReq->IpcId() == KLtsyDispatchPhoneRegisterCellInfoChangeNotificationApiId)
+		        {
+		        ret = KErrNone;
+		        }
+		    }
+		}
+	return TSYLOGSETEXITERR(ret);
+	} // CLtsyPhoneHandler::HandleGetPhoneCellInfoReqL
+
+TInt CLtsyPhoneHandler::HandleGetGetUsimServiceSupportReqL(TInt /*aApplicationNumber*/)
+/**
+ * This request is completed by invoking
+ * CCtsyDispatcherCallback::CallbackPhoneGetUsimServiceSupportComp()
+ * 
+ * @param aApplicationNumber The application number to check support for in the USIM.
+ * 
+ * 
+ * @return KErrNone on success, KErrNotSupported if this request is not supported,
+ * or another error code to indicate the failure otherwise.
+ */
+	{
+	TSYLOGENTRYEXIT;
+
+	TInt ret = KErrNotSupported;
+	return TSYLOGSETEXITERR(ret);
+	} // CLtsyPhoneHandler::HandleGetGetUsimServiceSupportReqL
+
+TInt CLtsyPhoneHandler::HandleGetCurrentActiveUsimApplicationReqL()
+/**
+ * This request is completed by invoking
+ * CCtsyDispatcherCallback::CallbackPhoneGetCurrentActiveUsimApplicationComp()
+ * 
+ * 
+ * @return KErrNone on success, KErrNotSupported if this request is not supported,
+ * or another error code to indicate the failure otherwise.
+ */
+	{
+	TSYLOGENTRYEXIT;
+
+	TInt ret = KErrNotSupported;
+	return TSYLOGSETEXITERR(ret);
+	} // CLtsyPhoneHandler::HandleGetCurrentActiveUsimApplicationReqL
+  
+TInt CLtsyPhoneHandler::HandleTerminateAllCallsReqL(TInt /*aCallId*/)
+/**
+ * This request is completed by invoking
+ * CCtsyDispatcherCallback::CallbackPhoneTerminateAllCallsComp()
+ * 
+ * @param aCallId if a call is in the connecting state then this parameter will contain the id of that call, else 0.
+ * 
+ * @return KErrNone on success, KErrNotSupported if this request is not supported,
+ * or another error code to indicate the failure otherwise.
+ */
+	{
+	LOGTEXT(_L8("[Ltsy Phone]  Starting CLtsyPhoneHandler::HandleTerminateAllCallsReqL()"));
+	
+	TInt ret = KErrNotSupported;
+	ret = iGloblePhone->CheckGlobalPhoneStatus();
+	if(ret == KErrNone)
+		{
+		CATHangUp* cHangUp = CATHangUp::NewL((*iGloblePhone), iCtsyDispatcherCallback);
+		iGloblePhone->iEventSignalActive = ETrue;
+		iGloblePhone->SetActiveRequest(cHangUp);
+		cHangUp->SetHangupOperator(CATHangUp::ERMobilePhoneAPI);
+		cHangUp->StartRequest();
+		}
+	return ret;
+	} // CLtsyPhoneHandler::HandleTerminateAllCallsReqL
+
+TInt CLtsyPhoneHandler::HandleGetSystemNetworkBandReqL()
+/**
+ * This request is completed by invoking
+ * CCtsyDispatcherCallback::CallbackPhoneGetSystemNetworkBandComp()
+ * 
+ * @return KErrNone on success, KErrNotSupported if this request is not supported,
+ * or another error code to indicate the failure otherwise.
+ */
+	{
+	TSYLOGENTRYEXIT;
+
+	TInt ret = KErrNotSupported;
+	return TSYLOGSETEXITERR(ret);
+	} // CLtsyPhoneHandler::HandleGetSystemNetworkBandReqL
+
+TInt CLtsyPhoneHandler::HandleSetSystemNetworkBandReqL(RMmCustomAPI::TBandSelection /*aBand*/, RMmCustomAPI::TNetworkModeCaps /*aMode*/)
+/**
+ * This request is completed by invoking
+ * CCtsyDispatcherCallback::CallbackPhoneSetSystemNetworkBandComp()
+ * 
+ * @param aBand the requested band
+ * @param aMode the requested mode
+ * 
+ * @return KErrNone on success, KErrNotSupported if this request is not supported,
+ * or another error code to indicate the failure otherwise.
+ */
+	{
+	TSYLOGENTRYEXIT;
+
+	TInt ret = KErrNotSupported;
+	return TSYLOGSETEXITERR(ret);
+	} // CLtsyPhoneHandler::HandleGetSystemNetworkBandReqL
+
+void CLtsyPhoneHandler::NotifyIpcRequestComplete(TInt aIpcId)
+/**
+ * This function was called by some IPC request after it complete the request 
+ * 
+ * If there are one more AT commands which need some interactions among them, the logic control should be put here.
+ * 
+ * @param aIpcId The IPC request Id
+ * 
+ * @return void
+ */
+    {
+    if(aIpcId == KLtsyDispatchPhoneRegisterCellInfoChangeNotificationApiId)
+        {
+        if(iPendingIpcId == KLtsyDispatchPhoneGetPhoneCellInfoApiId)
+            {
+            iGloblePhone->DeleteLastActiveRequest();
+            CATGetPhoneCellInfo* getPhoneCellInfo = NULL;
+            TRAPD(err,getPhoneCellInfo  = CATGetPhoneCellInfo::NewL(*iGloblePhone,iCtsyDispatcherCallback));
+            if(err != KErrNone)
+                {
+                RMobilePhone::TMobilePhoneCellInfoV9 cellInfo; 
+                iCtsyDispatcherCallback.CallbackPhoneGetPhoneCellInfoComp(err,cellInfo);
+                }
+            else
+                {
+                iGloblePhone->iEventSignalActive = ETrue;
+                iGloblePhone->SetActiveRequest(getPhoneCellInfo);
+                getPhoneCellInfo->SetIpcRequestCompleteObserver(this);
+                getPhoneCellInfo->SetIpcId(KLtsyDispatchPhoneGetPhoneCellInfoApiId);
+                getPhoneCellInfo->StartRequest();
+                iPendingIpcId = -1;
+                }
+            }
+        }
+    else if(aIpcId == KLtsyDispatchPhoneGetPhoneCellInfoApiId)
+        {
+        // enable to receive the notificaiton of cell info changed
+        iNotifyCellInfo->Enable();
+        }
+    else if(aIpcId == KLtsyDispatchPhoneGetCellInfoApiId)
+        {
+        iNotifyCellInfo->Enable();
+        }
+    else if(aIpcId == KLtsyDispatchPhoneGetNetworkRegistrationStatusApiId)
+        {
+        iNetworkRegStatusChange->Enable();
+        }
+    }
+
+// End of file