--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/cbsref/telephonyrefplugins/atltsy/handler/src/cltsyphonehandler.cpp Tue Aug 31 16:23:08 2010 +0300
@@ -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