--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/telephonyserverplugins/multimodetsy/Multimode/mPHONE.CPP Tue Feb 02 01:41:59 2010 +0200
@@ -0,0 +1,1293 @@
+// Copyright (c) 1997-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:
+// Implements phone based(multimode) functionality such as getting
+// signal, battery, network and network registration status inforamtion(and more).
+//
+//
+
+#include "mSLOGGER.H"
+#include "mPHONE.H"
+#include "mSMSMESS.H"
+#include "mPHBOOK.H"
+#include "Mphbkcom.h"
+#include "Mbattery.h"
+#include "Msignal.h"
+#include "mnetwork.h"
+#include "NOTIFY.H"
+#include <etslotnum.h>
+#include "mimsi.h"
+#include "Mownnum.h"
+#include <etelmmcs.h>
+#include "ATIO.H"
+#include "monstore.h"
+#include "gprs.h"
+#include "TSYCONFG.H"
+#include "ATINIT.H"
+#include "etsvr_slots.h"
+
+// This class is used when retreiving lists from the phone.
+CListReadAllAttempt* CListReadAllAttempt::NewL(RMobilePhone::TClientId* aId, TTsyReqHandle aReqHandle)
+ {
+ CListReadAllAttempt* read=new(ELeave) CListReadAllAttempt(aId, aReqHandle);
+ CleanupStack::PushL(read);
+ read->ConstructL();
+ CleanupStack::Pop();
+ return read;
+ }
+
+CListReadAllAttempt::CListReadAllAttempt(RMobilePhone::TClientId* aId, TTsyReqHandle aReqHandle)
+ :CBase()
+ {
+ iClient.iSessionHandle=aId->iSessionHandle;
+ iClient.iSubSessionHandle=aId->iSubSessionHandle;
+ iReqHandle=aReqHandle;
+ iListBuf = NULL;
+ }
+
+void CListReadAllAttempt::ConstructL()
+ {
+ }
+
+CListReadAllAttempt::~CListReadAllAttempt()
+ {
+ delete iListBuf;
+ }
+
+
+void CPhoneMobile::ClosePhone(TAny* aObj)
+//
+// Utility func for cleanup stack
+//
+ {
+ ((CObject*)aObj)->Close();
+ }
+
+//
+// CPhoneMobile
+//
+CPhoneMobile* CPhoneMobile::NewL()
+ {
+ CPhoneMobile* phone=new(ELeave) CPhoneMobile();
+ TCleanupItem newPhoneClose(ClosePhone,phone);
+ CleanupStack::PushL(newPhoneClose);
+ phone->ConstructL();
+ CleanupStack::Pop();
+ return phone;
+ }
+
+void CPhoneMobile::ConstructL()
+//
+// Creation of Global Params
+//
+ {
+ CPhoneHayes::ConstructL();
+ }
+
+CPhoneMobile::~CPhoneMobile()
+//
+ {
+ if(iGetDetectedNetworks) // This prevents an Access Violation when CommDB is missing
+ iGetDetectedNetworks->ResetAndDestroy();
+ delete iGetDetectedNetworks;
+ delete iPhoneBookInfo;
+ delete iATBattery;
+ delete iATSignal;
+ delete iATNetworkInfo;
+ delete iATSubscriberId;
+ delete iATOwnNumbers;
+ delete iATDetectNetwork;
+ }
+
+TInt CPhoneMobile::MultimodeInitL(TBool aExplicit)
+
+ {
+ if(aExplicit)
+ {
+ if( !iPhoneGlobals )
+ {
+ iPhoneGlobals = CPhoneGlobals::NewL(aExplicit);
+ iPhoneGlobals->iConfiguration->SetTableViewsL(iTableSettings);
+ }
+ }
+
+ CPhoneHayes::MultimodeInitL(aExplicit);
+
+ if(!iPhoneBookInfo)
+ iPhoneBookInfo=CATPhoneBookInfo::NewL(iIo,this,iInit,iPhoneGlobals);
+
+ if(!iATBattery)
+ iATBattery=CATGetBattery::NewL(iIo,this,iInit,iPhoneGlobals);
+
+ if(!iATSignal)
+ iATSignal=CATGetSignal::NewL(iIo,this,iInit,iPhoneGlobals);
+
+ if(!iATNetworkInfo)
+ iATNetworkInfo=CATNetworkInfo::NewL(iIo,this,iInit,iPhoneGlobals);
+
+ iPhoneGlobals->SetChangeOfNetworkPtr(iATNetworkInfo);
+
+ if(!iATSubscriberId)
+ iATSubscriberId=CATSubscriberId::NewL(iIo,this,iInit,iPhoneGlobals);
+
+ if(!iATOwnNumbers)
+ iATOwnNumbers=CATOwnNumbers::NewL(iIo,this,iInit,iPhoneGlobals);
+
+ if(!iATDetectNetwork)
+ iATDetectNetwork=CATDetectNetwork::NewL(iIo,this,iInit,iPhoneGlobals);
+
+ if(!iGetDetectedNetworks )
+ iGetDetectedNetworks = new(ELeave) CArrayPtrFlat<CListReadAllAttempt>(1);
+
+ return KErrNone;
+ }
+
+TInt CPhoneMobile::ExplicitInitialisationL(const TTsyReqHandle aTsyReqHandle, RMobilePhone::TMMTableSettings* aSettings)
+ {
+ // If we haven't initialised iPhoneGlobals, do so here.
+ // Either way, call CPhoneHayes::ControlledInitialisation().
+ if (iPhoneGlobals == NULL)
+ {
+ iTableSettings=*aSettings;
+ MultimodeInitL(ETrue);
+ iPhoneGlobals->iConfiguration->GetRequestedTableViewsL();
+ CPhoneHayes::ControlledInitialisation(aTsyReqHandle);
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ }
+ else
+ {
+ CPhoneHayes::ControlledInitialisation(aTsyReqHandle);
+ }
+
+ return KErrNone;
+ }
+
+
+TInt CPhoneMobile::ExplicitInitialisationCancel(const TTsyReqHandle aTsyReqHandle)
+/** Cancel explicit initialisation
+ *
+ * @param aTsyReqHandle const pointer to the request ID
+ * @return error code. KErrCancel
+ */
+ {
+ iInit->StopInit(aTsyReqHandle);
+ return KErrCancel;
+ }
+
+TInt CPhoneMobile::ControlledInitialisation(const TTsyReqHandle aTsyReqHandle)
+ {
+ TInt ret = KErrNone;
+
+ if (iPhoneGlobals == NULL)
+ {
+ TRAP(ret, MultimodeInitL(EFalse));
+ }
+
+ if (ret == KErrNone)
+ {
+ CPhoneHayes::ControlledInitialisation(aTsyReqHandle);
+ }
+
+ return ret;
+ }
+//
+// Gsm extended functions
+//
+
+CTelObject::TReqMode CPhoneMobile::ReqModeL(const TInt aIpc)
+ {
+//
+// What's the request mode
+//
+ CTelObject::TReqMode ret=0;
+
+ // we need to delay initialising the phone as we have not yet been given the IAP to use
+ if( iPhoneGlobals == NULL )
+ {
+ if(aIpc!=EMobilePhoneMMInitialise)
+ {
+ // original initialise()
+ MultimodeInitL(EFalse);
+ }
+ else
+ {
+ // initialiseMM() - temporarily hardwire IAP value (DEF036487)
+ iTableSettings.iLocId = KInternetAccessPoint;
+ MultimodeInitL(ETrue);
+ }
+ }
+
+ switch (aIpc)
+ {
+
+ case EMobilePhoneMMInitialise:
+ ret=KReqModeFlowControlObeyed | KReqModeMultipleCompletionEnabled;
+ break;
+
+ case EMobilePhoneNotifyCurrentNetworkChange:
+ case EMobilePhoneNotifyNetworkRegistrationStatusChange:
+ ret=KReqModeMultipleCompletionEnabled | KReqModeRePostImmediately;
+
+ break;
+
+ case EMobilePhoneGetPhoneStoreInfo:
+ case EMobilePhoneGetSignalStrength:
+ case EMobilePhoneGetBatteryInfo:
+ case EMobilePhoneGetNetworkRegistrationStatus:
+ case EMobilePhoneGetSubscriberId:
+ case EMobilePhoneGetCurrentNetwork:
+ case EMobilePhoneGetDetectedNetworksPhase1:
+ ret=KReqModeFlowControlObeyed;
+ break;
+
+ case EMobilePhoneGetCurrentMode:
+ case EMobilePhoneGetPhoneId:
+ case EMobilePhoneGetBatteryCaps:
+ case EMobilePhoneGetSignalCaps:
+ case EMobilePhoneGetIdentityCaps:
+ case EMobilePhoneGetMultimodeCaps:
+ case EMobilePhoneGetNetworkCaps:
+ case EMobilePhoneGetDetectedNetworksPhase2:
+ ret=0;
+ break;
+
+ default:
+ ret=CPhoneBase::ReqModeL(aIpc);
+ break;
+ }
+
+ // Check if the data port is currently loaned. If it is and the requested IPC
+ // is flow controlled then block Etel calling the IPC by leaving with KErrInUse
+ if(iPhoneGlobals && (ret&KReqModeFlowControlObeyed) && iPhoneGlobals->iPhoneStatus.iDataPortLoaned)
+ {
+ LOGTEXT2(_L8("ReqModeL Leaving with KErrInUse as data port is loaned (aIpc=%d)"),aIpc);
+ User::Leave(KErrInUse);
+ }
+
+ return ret;
+ }
+
+TInt CPhoneMobile::NumberOfSlotsL(const TInt aIpc)
+ {
+ // Return the number of slots (buffered in server)
+ // for any KReqRepostImmediately ipc calls in the above ReqModeL function
+ switch (aIpc)
+ {
+ case EMobilePhoneNotifyCurrentNetworkChange:
+ return (KSlotNotifyCurrentNetworkChange<4 ? 4 : KSlotNotifyCurrentNetworkChange);
+
+ case EMobilePhoneNotifyNetworkRegistrationStatusChange:
+ return KSlotNotifyNetworkRegistrationStatusChange;
+
+ default:
+ return CPhoneHayes::NumberOfSlotsL(aIpc);
+ }
+ }
+
+TInt CPhoneMobile::RegisterNotification(const TInt /*aIpc*/)
+ {
+ return KErrNone;
+ }
+
+TInt CPhoneMobile::DeregisterNotification(const TInt /*aIpc*/)
+ {
+ return KErrNone;
+ }
+
+TInt CPhoneMobile::CancelService(const TInt aIpc,const TTsyReqHandle aTsyReqHandle)
+ {
+ TInt ret=KErrNone;
+ // If an AT command class has been used to service a request, then try to cancel
+ // the sending of the AT command. If the AT command class is in an idle state
+ // the CancelCommand() function should do nothing.
+ switch (aIpc)
+ {
+ case EMobilePhoneMMInitialiseCancel:
+ ret= ExplicitInitialisationCancel(aTsyReqHandle);
+ break;
+
+ case EMobilePhoneNotifyNetworkRegistrationStatusChange:
+ ret=NotifyNetworkRegistrationStatusChangeCancel(aTsyReqHandle);
+ break;
+
+ case EMobilePhoneNotifyCurrentNetworkChange:
+ ret=NotifyCurrentNetworkChangeCancel(aTsyReqHandle);
+ break;
+
+ case EMobilePhoneGetSignalStrength:
+ iATSignal->CancelCommand(aTsyReqHandle);
+ break;
+
+ case EMobilePhoneGetBatteryInfo:
+ iATBattery->CancelCommand(aTsyReqHandle);
+ break;
+
+ case EMobilePhoneGetCurrentNetwork:
+ iATNetworkInfo->CancelCommand(aTsyReqHandle);
+ break;
+
+ case EMobilePhoneGetDetectedNetworksPhase1:
+ iATDetectNetwork->CancelCommand(aTsyReqHandle);
+ break;
+
+ case EMobilePhoneGetPhoneStoreInfo:
+ {
+ // Cancel both - as could be trying to get phonebook or own number store info
+ iATOwnNumbers->CancelCommand(aTsyReqHandle);
+ iPhoneBookInfo->CancelCommand(aTsyReqHandle);
+ }
+ break;
+
+ case EMobilePhoneGetSubscriberId:
+ iATSubscriberId->CancelCommand(aTsyReqHandle);
+ break;
+
+ case EMobilePhoneGetNetworkRegistrationStatus:
+ case EMobilePhoneGetCurrentMode:
+ case EMobilePhoneGetPhoneId:
+ // Can not cancel these requests because they are completed synchronously
+ break;
+
+ default:
+ ret=CPhoneBase::CancelService(aIpc,aTsyReqHandle);
+ }
+
+ return ret;
+ }
+
+
+TInt CPhoneMobile::ExtFunc(const TTsyReqHandle aTsyReqHandle, const TInt aIpc, const TDataPackage& aPackage)
+//
+// Dispatch Function
+//
+ {
+ // Prior to dispatch check that we're not setting up or in the middle of a data or fax call
+ if((iPhoneGlobals && iPhoneGlobals->iPhoneStatus.iPortAccess==EPortAccessDenied) || (iPhoneGlobals && iPhoneGlobals->iPhoneStatus.iMode == RPhone::EModeOnlineData))
+ {
+ LOGTEXT2(_L8("CPhoneMobile::ExtFunc (aIpc=%d)"),aIpc);
+ LOGTEXT(_L8("CPhoneMobile::ExtFunc\tPort Access Denied/Mode Online flag detected"));
+
+ switch(aIpc)
+ {
+ // These may interfere with the Fax, so error the request now...
+ case EMobilePhoneGetSignalStrength:
+ case EMobilePhoneGetBatteryInfo:
+ case EMobilePhoneGetCurrentNetwork:
+ case EMobilePhoneGetPhoneStoreInfo:
+ case EMobilePhoneGetNetworkRegistrationStatus:
+ case EMobilePhoneGetSubscriberId:
+ case EMobilePhoneGetDetectedNetworksPhase1:
+ LOGTEXT(_L8("CPhoneMobile::ExtFunc\tReturning KErrAccessDenied error"));
+ ReqCompleted(aTsyReqHandle, KErrAccessDenied);
+ return KErrNone; // Real error value returned in completion of clients request
+ default:
+ break;
+ }
+ }
+
+ //
+ // Asynchrous Requests
+ //
+ TAny* dataPtr1=aPackage.Ptr1();
+ TAny* dataPtr2=aPackage.Ptr2();
+ TInt ret = KErrNone;
+
+ switch (aIpc)
+ {
+ case EMobilePhoneMMInitialise:
+ {
+ TRAP(ret,ExplicitInitialisationL(aTsyReqHandle, REINTERPRET_CAST(RMobilePhone::TMMTableSettings*, dataPtr1)));
+ return ret;
+ }
+
+ case EMobilePhoneGetBatteryCaps:
+ return GetBatteryCaps(aTsyReqHandle, REINTERPRET_CAST(TUint32*, dataPtr1));
+
+ case EMobilePhoneGetBatteryInfo:
+ return GetBatteryInfo(aTsyReqHandle, REINTERPRET_CAST(RMobilePhone::TMobilePhoneBatteryInfoV1*, dataPtr1));
+
+ case EMobilePhoneGetSignalStrength:
+ return GetSignalStrength(aTsyReqHandle, REINTERPRET_CAST(TInt32*,dataPtr1), REINTERPRET_CAST(TInt8*, dataPtr2));
+
+ case EMobilePhoneGetSignalCaps:
+ return GetSignalCaps(aTsyReqHandle, REINTERPRET_CAST(TUint32*, dataPtr1));
+
+ case EMobilePhoneGetPhoneId:
+ return GetPhoneId(aTsyReqHandle,REINTERPRET_CAST(RMobilePhone::TMobilePhoneIdentityV1*, dataPtr1));
+
+ case EMobilePhoneGetCurrentNetwork:
+ return GetCurrentNetwork(aTsyReqHandle, aPackage.Des1n(), REINTERPRET_CAST(RMobilePhone::TMobilePhoneLocationAreaV1* ,dataPtr2));
+
+ case EMobilePhoneNotifyCurrentNetworkChange:
+ return NotifyCurrentNetworkChange(aTsyReqHandle, aPackage.Des1n(), REINTERPRET_CAST(RMobilePhone::TMobilePhoneLocationAreaV1* ,dataPtr2));
+
+ case EMobilePhoneGetDetectedNetworksPhase1:
+ return GetDetectedNetworksPhase1(aTsyReqHandle, REINTERPRET_CAST(RMobilePhone::TClientId*, dataPtr1), REINTERPRET_CAST(TInt*, dataPtr2)); // Last argument is TDes8* aBufSiz
+
+ case EMobilePhoneGetDetectedNetworksPhase2:
+ return GetDetectedNetworksPhase2(aTsyReqHandle, REINTERPRET_CAST(RMobilePhone::TClientId*, dataPtr1), aPackage.Des2n());
+
+ case EMobilePhoneGetPhoneStoreInfo:
+ switch (aPackage.Type())
+ {
+ case TDataPackage::EPackage1n2u:
+ // Client has called the version of RMobilePhone::GetPhoneStoreInfo
+ // with 3 arguments.
+ return GetPhoneStoreInfo(aTsyReqHandle, aPackage.Des1n(), aPackage.Des2u());// Last parameter is "TDesC* aName"
+ case TDataPackage::EPackage1n2n:
+ // Client has called the version of RMobilePhone::GetPhoneStoreInfo
+ // with 4 arguments.
+ return GetPhoneStoreInfo(aTsyReqHandle, aPackage.Des1n(), aPackage.Des2n());// Last parameter is RMobilePhoneStore::TMobilePhoneStoreInfoV1Pckg
+ default:
+ // No valid argument from RMobilePhone::GetPhoneStoreInfo found.
+ Panic(EUnexpectedState);
+ break;
+ } // switch (aPackage.Type())
+
+
+
+ case EMobilePhoneGetIdentityCaps:
+ return GetIdentityCaps(aTsyReqHandle, REINTERPRET_CAST(TUint32* ,dataPtr1));
+
+ case EMobilePhoneGetNetworkRegistrationStatus:
+ return GetNetworkRegistrationStatus(aTsyReqHandle,
+ REINTERPRET_CAST(RMobilePhone::TMobilePhoneRegistrationStatus*,dataPtr1));
+
+ case EMobilePhoneNotifyNetworkRegistrationStatusChange:
+ return NotifyNetworkRegistrationStatusChange(aTsyReqHandle,
+ REINTERPRET_CAST(RMobilePhone::TMobilePhoneRegistrationStatus*,dataPtr1));
+
+ case EMobilePhoneGetNetworkCaps:
+ return GetNetworkCaps(aTsyReqHandle, REINTERPRET_CAST(TUint32*, dataPtr1));
+
+ case EMobilePhoneGetCurrentMode:
+ return GetCurrentMode(aTsyReqHandle,REINTERPRET_CAST(RMobilePhone::TMobilePhoneNetworkMode*,dataPtr1));
+
+ case EMobilePhoneGetMultimodeCaps:
+ return GetMultimodeCaps(aTsyReqHandle, REINTERPRET_CAST(TUint32*,dataPtr1));
+
+ case EMobilePhoneGetSubscriberId:
+ return GetSubscriberId(aTsyReqHandle,
+ static_cast<RMobilePhone::TMobilePhoneSubscriberId*>(dataPtr1));
+
+ default:
+ LOGTEXT2(_L8("CPhoneMobile::ExtFunc\tunsupported request %d"), aIpc);
+ ReqCompleted(aTsyReqHandle, KErrNotSupported);
+ return KErrNone; // Real error value returned in completion of clients request
+ }
+ }
+
+
+//
+// Implemented Phone Functions
+//
+
+CTelObject* CPhoneMobile::OpenNewObjectL(TDes& /*aName*/)
+ {
+
+ User::Leave(KErrNotSupported);
+ return NULL;
+ }
+
+
+CTelObject* CPhoneMobile::OpenNewObjectByNameL(const TDesC& aName)
+/**
+ * Open a new line. Opens fax line even if phone does not support it, as that information
+ * may not be available (init sequence may not have reached that far.)
+ */
+ {
+
+ if(!iPhoneGlobals)
+ {
+ MultimodeInitL(EFalse);
+ }
+
+ if (aName.Compare(KETelSmsMessaging)==KErrNone)
+ {
+ iSmsMessaging = CMobileSmsMessaging::NewL(iIo,iInit,iPhoneGlobals);
+ return iSmsMessaging;
+ }
+
+ if (!aName.CompareF(KPacketName))
+ {
+ iGprsService = CGprs::NewL(iIo, iInit, iPhoneGlobals);
+ return iGprsService;
+ }
+
+ // Check if the name specified is the own number store. If it is, create the store.
+ if (aName.Compare(KETelOwnNumberStore)==KErrNone)
+ {
+ CMobileONStore* ownNumberStore=CMobileONStore::NewL(iIo,iInit,iPhoneGlobals);
+ return ownNumberStore;
+ }
+
+ TStorageType storageType;
+ TBool supported;
+ // If the name is in the list of known phone book names check to see
+ // if it supported by the current modem/phone
+ if (IsListedPhoneBook(aName,storageType,supported))
+ {
+ if (supported && storageType.Length()>0)
+ {
+ CMobilePhonebookStore* phoneBook=CMobilePhonebookStore::NewL(iIo,iInit,iPhoneGlobals,storageType);
+ return phoneBook;
+ }
+ else
+ {
+ if (!supported)
+ User::Leave(KErrNotSupported);
+ else
+ User::Leave(KErrUnknown);
+ return NULL;
+ }
+ }
+
+ // Use base class to open a line object
+ return CPhoneHayes::OpenNewObjectByNameL(aName);;
+ }
+
+
+TBool CPhoneMobile::IsListedPhoneBook(const TDesC& aName,TDes8& aStorageType,TBool& aSupported) const
+/*
+ * Check whether aName is a valid phone book name. If it is then if supported by 07.07
+ * return the memory storage type (used by AT commands) in aStorageType and whether it
+ * is supported by the current ME in aSupported.
+ */
+ {
+
+ aStorageType.SetLength(0);
+ const TUint flag=iPhoneGlobals->iPhoneStatus.iSupportedPhoneBookStorageFlag;
+
+ if (aName.CompareF(KETelMeAdnPhoneBook)==KErrNone)
+ {
+ aStorageType.Copy(KMEStorage);
+ aSupported=((flag&KPhoneBookMEStorage)!=0);
+ return ETrue;
+ }
+ if (aName.CompareF(KETelMeDialledPhoneBook)==KErrNone) //LAST_DIALLED_PHONEBOOK
+ {
+ aStorageType.Copy(KDCStorage);
+ aSupported=((flag&KPhoneBookLastDialledStorage)!=0);
+ return ETrue;
+ }
+ if (aName.CompareF(KETelMeMissedPhoneBook)==KErrNone)
+ {
+ aStorageType.Copy(KMCStorage);
+ aSupported=((flag&KPhoneBookMissedCallsStorage)!=0);
+ return ETrue;
+ }
+ if (aName.CompareF(KETelMeReceivedPhoneBook)==KErrNone)
+ {
+ aStorageType.Copy(KRCStorage);
+ aSupported=((flag&KPhoneBookReceivedCallsStorage)!=0);
+ return ETrue;
+ }
+ if (aName.CompareF(KETelCombinedAdnPhoneBook)==KErrNone)
+ {
+ aStorageType.Copy(KMTStorage);
+ aSupported=((flag&KPhoneBookMTStorage)!=0);
+ return ETrue;
+ }
+ if (aName.CompareF(KETelTaAdnPhoneBook)==KErrNone)
+ {
+ aStorageType.Copy(KTAStorage);
+ aSupported=((flag&KPhoneBookTAStorage)!=0);
+ return ETrue;
+ }
+ if (aName.CompareF(KETelIccAdnPhoneBook)==KErrNone)
+ {
+ aStorageType.Copy(KSMStorage);
+ aSupported=((flag&KPhoneBookSMStorage)!=0);
+ return ETrue;
+ }
+ if (aName.CompareF(KETelIccFdnPhoneBook)==KErrNone)
+ {
+ aStorageType.Copy(KFDStorage);
+ aSupported=((flag&KPhoneBookFDStorage)!=0);
+ return ETrue;
+ }
+ if (aName.CompareF(KETelIccLndPhoneBook)==KErrNone)
+ {
+ aStorageType.Copy(KLDStorage);
+ aSupported=((flag&KPhoneBookLDStorage)!=0);
+ return ETrue;
+ }
+ if (aName.CompareF(KETelOwnNumberStore)==KErrNone)
+ {
+ aStorageType.Copy(KONStorage);
+ aSupported=((flag&KPhoneBookOwnNumbersStorage)!=0);
+ return ETrue;
+ }
+ if (aName.CompareF(KETelEmergencyNumberStore)==KErrNone)
+ {
+ aStorageType.Copy(KENStorage);
+ aSupported=((flag&KPhoneBookEmergencyStorage)!=0);
+ return ETrue;
+ }
+ if (aName.CompareF(KETelIccSdnPhoneBook)==KErrNone)
+ {
+ aStorageType.Copy(KSNStorage);
+ aSupported=((flag&KPhoneBookServiceNumberStorage)!=0);
+ return ETrue;
+ }
+ return EFalse;
+ }
+
+//
+// Extended functions for Multimode
+
+TInt CPhoneMobile::GetPhoneId(const TTsyReqHandle aTsyReqHandle,RMobilePhone::TMobilePhoneIdentityV1* aId)
+/** Get Phone Identification
+ *
+ * This method gets information about the mobilephone using cashed information
+ * from the initialisation of the phone.
+ * @param aTsyReqHandle the request ID
+ * @param aId contains information of manufacturer, model, revision and serialnumber.
+ * @return error code. KErrNone
+ */
+
+ {
+ aId->iManufacturer = iPhoneGlobals->iPhoneId.iManufacturer;
+ aId->iModel = iPhoneGlobals->iPhoneId.iModel;
+ aId->iRevision = iPhoneGlobals->iPhoneId.iRevision;
+ aId->iSerialNumber = iPhoneGlobals->iPhoneId.iSerialNumber;
+ ReqCompleted(aTsyReqHandle, KErrNone);
+ return KErrNone;
+ }
+
+
+TInt CPhoneMobile::GetIdentityCaps(const TTsyReqHandle aTsyReqHandle, TUint32* aIdentityCaps)
+/** Get identity capabilities
+ *
+ * This method gets information about the capabilities to retrieve information about
+ * the phone and subscriber. Information regarding manufacturer, phone model, revision
+ * of the phone, serialnumber of the phone and subscriber ID is retrieved during initialisation.
+ * Cashed information from the initialisation is used.
+ * @param aTsyReqHandle the request ID
+ * @param aIdentityCaps contains the capability information(capabilities to get manufacturer, phone model, revision of the phone, serialnumber of the phone and subscriber id)
+ * @return error code. KErrNone
+ */
+ {
+
+ *aIdentityCaps = iPhoneGlobals->iPhoneIdCaps;
+
+ if (*aIdentityCaps == 0)
+ ReqCompleted(aTsyReqHandle, KErrNotSupported);
+ else
+ ReqCompleted(aTsyReqHandle, KErrNone);
+
+ return KErrNone;
+ }
+
+
+TInt CPhoneMobile::GetSignalStrength(const TTsyReqHandle aTsyReqHandle,
+ TInt32* aSignalStrength, TInt8* aBar)
+/** Signal Strength
+ *
+ * This method receivs a request from the server to get the signal strength.
+ * The the request is passed on to the CATGetSignal which gets the information
+ * from the MS using the AT command AT+CSQ.
+ * @param aTsyReqHandle the request ID
+ * @param aSignalStrength pointer to the signalstrength. Can take the values -113dB to -53dB and 99, where 99 means signal is "not known or not detectable".
+ * @param aBar pointer to the number of signal bars that are to be shown by the client. Can take the values (-1) to 5.
+ * @return error code. KErrNone
+ */
+
+ {
+ LOGTEXT(_L8("MMTsy:\tCPhoneMobile::GetSignalStrength"));
+ if (!iPhoneGlobals->iSignalCaps)
+ // No signal strength capabilites - so error request
+ ReqCompleted(aTsyReqHandle, KErrNotSupported);
+ else
+ {
+ iSignalPtrs.iSignalStrength = aSignalStrength;
+ iSignalPtrs.iBar = aBar;
+ iATSignal->ExecuteCommand(aTsyReqHandle, &iSignalPtrs);
+ }
+
+ return KErrNone;
+ }// end of CPhoneMobile::GetSignalStrength
+
+
+TInt CPhoneMobile::GetSignalCaps(const TTsyReqHandle aTsyReqHandle, TUint32* aSignalCaps)
+/** Signal capabilities
+ *
+ * This method passes back the signal capabilities to the client. The information is
+ * extracted during the initialistaion and than cashed in the TSY for later use.
+ * @param aTsyReqHandle the request ID
+ * @param aCaps, pointer to the capabilities
+ * @return error code.
+ */
+
+ {
+ //The signal capabilities are extracted during the initialisationsequence and saved in iPhoneGlobals->iSignalCaps.
+ *aSignalCaps=iPhoneGlobals->iSignalCaps;
+
+ if (*aSignalCaps == 0)
+ ReqCompleted(aTsyReqHandle, KErrNotSupported);
+ else
+ ReqCompleted(aTsyReqHandle, KErrNone);
+
+ return KErrNone;
+ }
+
+
+TInt CPhoneMobile::GetMultimodeCaps(const TTsyReqHandle aTsyReqHandle, TUint32* aMultimodeCaps)
+/** Get Multimode Capabilities
+ *
+ * This method returnes the multimode capabilities for the phone.
+ * This TSY always supports GSM (which is hard coded) and may support
+ * GPRS if the attached phone supports it.
+ * @param aTsyReqHandle the request ID
+ * @param aMultimodeCaps, Pointer to the multimode capability to return.
+ * @return error code. KErrNone
+ */
+ {
+ // This TSY always supports GSM
+ *aMultimodeCaps = 0;
+
+ *aMultimodeCaps |= RMobilePhone::KCapsGsmSupported;
+
+ // The GPRS capability of the phone is determined by the class
+ // CATInit during the initialisation dialogue.
+ //
+ if (iPhoneGlobals->iGprsMaxNumContexts != 0)
+ {
+ *aMultimodeCaps |= RMobilePhone::KCapsGprsSupported;
+ }
+
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ return KErrNone;
+ }
+
+
+TInt CPhoneMobile::GetPhoneStoreInfo(const TTsyReqHandle aTsyReqHandle, TDes8* aInfo,TDesC* aName)
+/** Get phonestore information
+ *
+ * This method returns information about a store specified by aName in aInfo.
+ * This method only supports phonebooks and own number store. Other stores are
+ * either not supported by this TSY or opned from other subsessions.
+ * In the case when informtion about a phonebook the request is passed on to the
+ * CATPhopnebookInfo class which executes the AT command
+
+ * @param aTsyReqHandle const pointer to the request ID
+ * @param aInfo Pointer to the struct to contain the information about the specified store
+ * @param aName The name of the store to get information about.
+ * @return error code.
+ */
+
+ {
+ LOGTEXT2(_L8("MMTsy:\tCPhoneMobile::GetPhoneStoreInfo aTsyReqHandle = %d"), aTsyReqHandle);
+ TStorageType storageType;
+ TBool supported;
+
+ TBool ret = IsListedPhoneBook(*aName, storageType, supported);
+ if (aName->CompareF(KETelOwnNumberStore)==KErrNone)
+ {
+ // Getting own number store inormation.
+ iATOwnNumbers->GetInfo(aTsyReqHandle,aInfo);
+ }
+ else if (ret && supported)
+ {
+ iPhoneBookInfo->SetStorageType(storageType);
+ iPhoneBookInfo->ExecuteCommand(aTsyReqHandle,aInfo);
+ }
+ else
+ {
+ LOGTEXT2(_L8("MMTsy:\tCPhoneMobile::GetPhoneStoreInfo aTsyReqHandle = %d ReqCompleted(KErrNotSupported)"), aTsyReqHandle);
+ ReqCompleted(aTsyReqHandle, KErrNotSupported);
+ }
+
+ return KErrNone;
+ }
+
+TInt CPhoneMobile::GetPhoneStoreInfo(const TTsyReqHandle aTsyReqHandle, TDes8* aStoreNameIccType,TDes8* aInfo)
+/** Get phonestore information
+ *
+ * This method returns information about a store specified by aName in aInfo.
+ * This method only supports phonebooks and own number store. Other stores are
+ * either not supported by this TSY or opened from other subsessions.
+ * In the case when informtion about a phonebook the request is passed on to the
+ * CATPhopnebookInfo class which executes the AT command
+
+ * @param aTsyReqHandle const pointer to the request ID
+ * @param aStoreNameIccType contains a RMobilePhone::TPhoneStoreNameAndIccType including the store name and Icc type.
+ * @param aInfo Pointer to the struct to contain the information about the specified store
+ * @return error code.
+ */
+
+ {
+ LOGTEXT2(_L8("MMTsy:\tCPhoneMobile::GetPhoneStoreInfo aTsyReqHandle = %d"), aTsyReqHandle);
+
+ RMobilePhone::TPhoneStoreNameAndIccType* phoneStoreNameAndIccType =
+ reinterpret_cast<RMobilePhone::TPhoneStoreNameAndIccType*>
+ (const_cast<TUint8*>(aStoreNameIccType->Ptr()));
+
+ TDesC* mode = reinterpret_cast<TDesC*>(&phoneStoreNameAndIccType->iMode);
+ if (*mode != KEtelGsmPhoneBookType)
+ {
+ LOGTEXT2(_L8("MMTsy:\tCPhoneMobile::GetPhoneStoreInfo aTsyReqHandle = %d ReqCompleted(KErrNotSupported)"), aTsyReqHandle);
+ ReqCompleted(aTsyReqHandle, KErrNotSupported);
+ return KErrNone;
+ }
+ TDesC* storeName = reinterpret_cast<TDesC*>(&phoneStoreNameAndIccType->iStoreName);
+
+ TStorageType storageType;
+ TBool supported;
+
+ TBool ret = IsListedPhoneBook(*storeName, storageType, supported);
+ if (storeName->CompareF(KETelOwnNumberStore)==KErrNone)
+ {
+ // Getting own number store information.
+ iATOwnNumbers->GetInfo(aTsyReqHandle,aInfo);
+ }
+ else if (ret && supported)
+ {
+ iPhoneBookInfo->SetStorageType(storageType);
+ iPhoneBookInfo->ExecuteCommand(aTsyReqHandle,aInfo);
+ }
+ else
+ {
+ LOGTEXT2(_L8("MMTsy:\tCPhoneMobile::GetPhoneStoreInfo aTsyReqHandle = %d ReqCompleted(KErrNotSupported)"), aTsyReqHandle);
+ ReqCompleted(aTsyReqHandle, KErrNotSupported);
+ }
+ return KErrNone;
+ }
+
+void CPhoneMobile::CurrentNetworkInfo(CATNetworkInfo::TTsyNetworkInfo* aNetworkInfo) const
+ {
+ iATNetworkInfo->GetCurrentNetworkInfo(aNetworkInfo);
+ }
+
+
+TInt CPhoneMobile::GetCurrentNetwork(const TTsyReqHandle aTsyReqHandle, TDes8* aNetworkInfoPckg,
+ RMobilePhone::TMobilePhoneLocationAreaV1* aArea)
+/** Get Current Network Info
+ *
+ * This method gets information about the current state of the network,
+ * such as network name(short and long), status and mode of the network etc.
+ * @param aTsyReqHandle the request ID
+ * @param aNetworkInfoPckg pointer to a packet of TMobilePhoneNetworkInfoV1Pckg type.
+ * @param aArea Pointer to a struct of the type TMobilePhoneLocationAreaV1.
+ * @return error code.
+ */
+ {
+ LOGTEXT(_L8("MMTsy:\tCPhoneMobile::GetCurrentNetwork"));
+
+ RMobilePhone::TMobilePhoneNetworkInfoV1Pckg* networkPckg = static_cast<RMobilePhone::TMobilePhoneNetworkInfoV1Pckg*>(aNetworkInfoPckg);
+ // The networkPckg is finally unpacked to be set in CATNetworkInfo::GetCurrentNetworkInfo
+
+ // Check if retrieval of network information is supported.
+ if (iPhoneGlobals->iNetworkCaps & RMobilePhone::KCapsGetCurrentNetwork)
+ {
+ iPhoneGlobals->iNetworkMode = GetMode(); //Updating the network mode.
+ //This is then used in CATNetworkInfo::GetCurrentNetworkInfo.
+ iNetworkInfoPtrs.iNetworkInfoPckg = networkPckg;
+ iNetworkInfoPtrs.iArea = aArea;
+
+ // Need to read the network information
+ iATNetworkInfo->ExecuteCommand(aTsyReqHandle, &iNetworkInfoPtrs);
+ }
+ else
+ {
+ ReqCompleted(aTsyReqHandle,KErrNotSupported);
+ }
+
+ return KErrNone;
+ }
+
+
+TInt CPhoneMobile::NotifyCurrentNetworkChange(const TTsyReqHandle aTsyReqHandle, TDes8* aNetworkInfoPckg,
+ RMobilePhone::TMobilePhoneLocationAreaV1* aArea)
+/** Notification of Current Network change
+ *
+ * This method gets information about the current state of the network, such as network name(short and long),
+ * status and mode of the network etc, when the network changes.
+ * @param aTsyReqHandle the request ID
+ * @param aNetworkInfoPckg pointer to a packet of the type TMobilePhoneNetworkInfoV1Pckg.
+ * @param aArea Pointer to a struct of the type TMobilePhoneLocationAreaV1.
+ * @return error code.
+ */
+ {
+ if (iPhoneGlobals->iNetworkCaps & RMobilePhone::KCapsNotifyCurrentNetwork) // Check if notification is supported.
+ {
+ RMobilePhone::TMobilePhoneNetworkInfoV1Pckg* networkPckg = static_cast<RMobilePhone::TMobilePhoneNetworkInfoV1Pckg*>(aNetworkInfoPckg);
+ CATNetworkInfo::TTsyNetworkInfo networkInfo; // Have to put the inforamtion in a struct to be able to pass it on in the TSY.
+ networkInfo.iNetworkInfoPckg = networkPckg;
+ networkInfo.iArea = aArea;
+
+ iPhoneGlobals->iNotificationStore->RegisterNotification(ECurrentNetwork,aTsyReqHandle,this, &networkInfo); // posting the notification request
+ }
+ else
+ ReqCompleted(aTsyReqHandle,KErrNotSupported);
+
+ return KErrNone;
+ }
+
+
+TInt CPhoneMobile::NotifyCurrentNetworkChangeCancel(const TTsyReqHandle aTsyReqHandle)
+/** Notification of Current Network change Cancel
+ *
+ * This method cancels an outstanding NotifyCurrentNetworkChange request.
+ * @param aTsyReqHandle the request ID that belong to the request to be cancelled
+ * @return error code.
+ */
+ {
+ if (iPhoneGlobals->iNetworkCaps & RMobilePhone::KCapsNotifyCurrentNetwork) // Check if notification is supported.
+ {
+ LOGTEXT(_L8("PhoneMM:\tCurrent Network Change Notification cancelled"));
+ iPhoneGlobals->iNotificationStore->RemoveNotification(aTsyReqHandle);
+ }
+ // else - Request not posted in the first place, so do nothing
+
+ return KErrNone;
+ }
+
+
+TInt CPhoneMobile::GetNetworkCaps(const TTsyReqHandle aTsyReqHandle, TUint32* aNetworkCaps)
+/** Get Multimode Capabilities
+ *
+ * This method returnes the network capabilities for the phone. The capabilities are
+ * extracted during the initialisation(ATINIT.cpp) using AT+CREG and AT+COPS.
+ * @param aTsyReqHandle the request ID
+ * @param aNetworkCaps, Pointer to the network capabilities.
+ * @return error code. KErrNone
+ */
+ {
+ *aNetworkCaps = iPhoneGlobals->iNetworkCaps;
+
+ if (*aNetworkCaps == 0)
+ ReqCompleted(aTsyReqHandle, KErrNotSupported);
+ else
+ ReqCompleted(aTsyReqHandle, KErrNone);
+ return KErrNone;
+ }
+
+
+RMobilePhone::TMobilePhoneRegistrationStatus CPhoneMobile::RegistrationStatus() const
+ {
+ return iPhoneGlobals->iPhoneStatus.iRegistrationStatus;
+ }
+
+TInt CPhoneMobile::GetNetworkRegistrationStatus(const TTsyReqHandle aTsyReqHandle,
+ RMobilePhone::TMobilePhoneRegistrationStatus* aRegistrationStatus)
+/** Network Registration Status
+ *
+ * Gives information about the network registration status
+ *(ENotRegisterdNotSearching, ERegisterdOnHomeNetwork, ENotRegisterdSearching, ERegistrationDenied,
+ * EUnknown or ERegisteredRoaming). The AT command +CREG is used to get this information.
+ * @param aTsyReqHandle the request ID
+ * @param aRegistrationStatus, pointer to be set to point to the registration status.
+ * @return error code. KErrNone
+ */
+ {
+ *aRegistrationStatus = RegistrationStatus();
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ return KErrNone;
+ }
+
+
+TInt CPhoneMobile::NotifyNetworkRegistrationStatusChange(const TTsyReqHandle aTsyReqHandle,
+ RMobilePhone::TMobilePhoneRegistrationStatus* aRegistrationStatus)
+/** Notify change of Network Registration Status
+ *
+ * @param aTsyReqHandle const pointer to the request ID
+ * @param aRegistrationStatus, pointer to be set to point to the registartion status.
+ * @return error code. KErrNone
+ */
+ {
+ if (iPhoneGlobals->iNetworkCaps & RMobilePhone::KCapsNotifyRegistrationStatus) // Check if notification is supported.
+ {
+ LOGTEXT(_L8("CPhoneMobile:\tNetwork Registration Status Change Notification loged"));
+ iPhoneGlobals->iNotificationStore->RegisterNotification(ERegistrationStatus,aTsyReqHandle,this,aRegistrationStatus);
+ return KErrNone;
+ }
+
+ ReqCompleted(aTsyReqHandle,KErrNotSupported);
+ return KErrNone;
+ }
+
+
+TInt CPhoneMobile::NotifyNetworkRegistrationStatusChangeCancel(const TTsyReqHandle aTsyReqHandle)
+/** Notify change of Network Registration Status Cancel
+ *
+ * @param aTsyReqHandle const pointer to the request ID
+ * @return error code. KErrNone
+ */
+
+ {
+ if (iPhoneGlobals->iNetworkCaps & RMobilePhone::KCapsNotifyRegistrationStatus) // Check if notification is supported.
+ {
+ LOGTEXT(_L8("CPhoneMobile:\tNetwork Registration Status Change Notification cancelled"));
+ iPhoneGlobals->iNotificationStore->RemoveNotification(aTsyReqHandle);
+ }
+ // else - Request not posted in the first place, so do nothing
+
+ return KErrNone;
+ }
+
+
+TInt CPhoneMobile::GetCurrentMode(const TTsyReqHandle aTsyReqHandle, RMobilePhone::TMobilePhoneNetworkMode* aNetworkMode)
+/** Get Network Mode
+ *
+ * Gives information about the current network mode, such as ENetworkModeUnknown,ENetworkModeUnregistered or ENetworkModeGsm.
+ * TDM, AMPS, UMTS, WCDMA is not supported by this TSY
+ * @param aTsyReqHandle the request ID
+ * @param aNetworkMode The networkmode to be returned(as above)
+ * @return error code. KErrNone
+ */
+ {
+ if (iPhoneGlobals->iNetworkCaps & RMobilePhone::KCapsGetCurrentMode)
+ {
+ *aNetworkMode = GetMode(); //Calling local method to get the networkmode
+ ReqCompleted(aTsyReqHandle, KErrNone);
+ return KErrNone;
+ }
+
+ ReqCompleted(aTsyReqHandle,KErrNotSupported);
+ return KErrNone;
+ }
+
+TInt CPhoneMobile::GetBatteryCaps(const TTsyReqHandle aTsyReqHandle, TUint32* aBatteryCaps)
+/** Battery Capabilities
+ *
+ * This method passes information about the battery capabilities back to the client.
+ * @param aTsyReqHandle the request ID.
+ * @param aBatteryCaps, passes back the battery capabilities.
+ * @return error code.KErrNone
+ */
+ {
+ // The battery capabilities are extracted during the initialisation(ATINIT.CPP)
+ // and stored in iPhoneGlobals->iBatteryCaps to be retrieved when needed.
+ *aBatteryCaps=iPhoneGlobals->iBatteryCaps;
+
+ if (*aBatteryCaps == 0)
+ ReqCompleted(aTsyReqHandle, KErrNotSupported);
+ else
+ ReqCompleted(aTsyReqHandle, KErrNone);
+
+ return KErrNone;
+ }
+
+
+TInt CPhoneMobile::GetBatteryInfo(const TTsyReqHandle aTsyReqHandle,
+ RMobilePhone::TMobilePhoneBatteryInfoV1* aBatteryInfo)
+/** Battery information
+ *
+ * This method passes a request from the etel server to get battery information from
+ * the GSM phone on to the CATGetBattery class. CATGetBattery executes the AT command
+ * AT+CBC to get battery information. The information reurned is status and precent of
+ * capacity remaining.
+ * @param aTsyReqHandle the request ID.
+ * @param aBatteryInfo, pointer to a struct for infortmation about battery status and charge level.
+ * @return error code.KErrNone
+ */
+
+ {
+ if (!iPhoneGlobals->iBatteryCaps)
+ // There are no battery capabilities - so error request
+ ReqCompleted(aTsyReqHandle, KErrNotSupported);
+ else
+ iATBattery->ExecuteCommand(aTsyReqHandle, aBatteryInfo);
+
+ return KErrNone;
+ }
+
+
+TInt CPhoneMobile::GetSubscriberId(TTsyReqHandle aTsyReqHandle, RMobilePhone::TMobilePhoneSubscriberId* aId)
+/** Get Subscriber Id
+ *
+ * This method passes the request for the IMSI number on to CATSubscriberId, if the capabilities
+ * are right. The AT command AT+CIMI is used to retrieve the information from the phone.
+ * @param aTsyReqHandle the request ID
+ * @param aId,a pointer to the memory where the subscriber id should be stored.
+ * @return error code.
+ */
+
+ {
+ // Intialise the clients data in case they ignore our completion code
+ // and use the ID we supplied them.
+ aId->Zero();
+
+ if ((iPhoneGlobals->iPhoneIdCaps & RMobilePhone::KCapsGetSubscriberId) &&
+ (iATSubscriberId->CachedValue(*aId)))
+ {
+ // The IMSI has already been retrieved and cached within iATSubscriberId
+ ReqCompleted(aTsyReqHandle,KErrNone);
+ }
+ else if (iPhoneGlobals->iPhoneIdCaps & RMobilePhone::KCapsGetSubscriberId)
+ {
+ // Pass the request in to the CATSubscriberId class which executes AT+CIMI.
+ iATSubscriberId->ExecuteCommand(aTsyReqHandle,aId);
+ }
+ else
+ ReqCompleted(aTsyReqHandle,KErrNotSupported);
+
+ return KErrNone;
+ }
+
+
+//*******************************************
+//* Get Detected Networks
+//*******************************************
+TInt CPhoneMobile::GetDetectedNetworksPhase1(const TTsyReqHandle aTsyReqHandle,
+ RMobilePhone::TClientId* aClient,
+ TInt* aBufSize)
+/** Get Detected Networks Phase 1
+ *
+ * If the GetDetectedNetworksPhase1L should leave this method takes care of that and
+ * makes a premature ReqCompleted to the client.
+ *
+ * @param aTsyReqHandle the request ID
+ * @param aClient The client sends down a handle that is saved together with the
+ * list so the list can be returned to the right client in phase 2.
+ * @param aBufSiz The size of the retrieved network lidt. The size is set in
+ * @return error code.
+ */
+
+ {
+ LOGTEXT(_L8("MMTsy::GetDetectedNetworksPhase1 called"));
+ TInt ret=KErrNone;
+ TInt leaveCode=KErrNone;
+ TRAP(leaveCode, ret=GetDetectedNetworksPhase1L(aTsyReqHandle, aClient, aBufSize););
+ if (leaveCode != KErrNone)
+ ReqCompleted(aTsyReqHandle,leaveCode);
+ return ret;
+ }
+
+
+TInt CPhoneMobile::GetDetectedNetworksPhase1L(TTsyReqHandle aTsyReqHandle,
+ RMobilePhone::TClientId* aClient,
+ TInt* aBufSize)
+/** Get Detected Networks Phase 1
+ *
+ * Phase 1 retrieves the network list with help of AT+COPS=?,
+ * the memory space needed to store the list is then calculated
+ * and returned to the client.The returned list is saved to be
+ * copied to the client in phase 2, when the client has alocated memory for it.
+ * The actuall execution of the AT command (AT+COPS=?) is done in the CATDetectNetwork class.
+ *
+ * @param aTsyReqHandle const pointer to the request ID
+ * @param aClient The client sends down a handle that is saved together with the
+ * list so the list can be returned to the right client in phase 2.
+ * @param aBufSize The size of the retrieved network. The size is set in CATDetectNetwork::ParseResponseL().
+ * @return error code.
+ */
+ {
+
+ LOGTEXT(_L8("CPhoneMobile::GetDetectedNetworksPhase1 called"));
+ CListReadAllAttempt* read=CListReadAllAttempt::NewL(aClient,aTsyReqHandle);
+ CleanupStack::PushL(read);
+
+ iNetworkListInfoPtrs.iBufSize = aBufSize;
+ iNetworkListInfoPtrs.iBufPtr = &(read->iListBuf);
+ iGetDetectedNetworks->AppendL(read);
+
+ iATDetectNetwork->ExecuteCommand(aTsyReqHandle, &iNetworkListInfoPtrs);
+
+ // pop the CListReadAllAttempt (read)
+ CleanupStack::Pop();
+ return KErrNone;
+ }
+
+
+TInt CPhoneMobile::GetDetectedNetworksPhase2(const TTsyReqHandle aTsyReqHandle, RMobilePhone::TClientId* aClient, TDes8* aBuf)
+/** Get detected networks phase 2
+ *
+ * In this metod the list which was retrieved during phase 1 is copied to
+ * the memory which the client has allocated for this purose.
+ * @param aTsyReqHandle Const pointer to the request ID
+ * @param aClient Handle to the client which list we are looking for.
+ * @param aBuf Pointer to the memory that the etelmm has allocated.
+ * @return error code.
+ */
+ {
+
+ LOGTEXT(_L8("CPhoneMobile::GetDetectedNetworksPhase2 called"));
+ CListReadAllAttempt* read=NULL;
+ TInt numberOfLists = iGetDetectedNetworks->Count();
+
+ // Find the get detected network attempt from this client
+ for (TInt i = 0; i < numberOfLists; ++i)
+ {
+ read = iGetDetectedNetworks->At(i);
+ if ((read->iClient.iSessionHandle==aClient->iSessionHandle) &&
+ (read->iClient.iSubSessionHandle==aClient->iSubSessionHandle))
+ {
+ TPtr8 bufPtr((read->iListBuf)->Ptr(0));
+
+ aBuf->Copy(bufPtr); // Copy the streamed list to the client
+ delete read;
+ iGetDetectedNetworks->Delete(i);
+ ReqCompleted(aTsyReqHandle,KErrNone); // Completes the retrieval of a network list succesfully.
+ return KErrNone;
+ }
+ }
+
+ Panic(EIllegalEvent);
+ return(KErrNotFound);
+ }
+
+
+void CPhoneMobile::CompleteDetectedNetworksCancel(const TTsyReqHandle aTsyReqHandle)
+/** CompleteDetectedNetworksCancel
+ *
+ * This method is called from the CATDetectNetworks class if a cancel is succesful
+ * It cleans-up the client's stored request data
+ * @param aTsyReqHandle Const pointer to the request ID
+ * @return error code.
+ */
+ {
+ LOGTEXT(_L8("CPhoneMobile::GetDetectedNetworksCancel called"));
+ // Remove the read all attempt from iGetDetectedNetworks
+ CListReadAllAttempt* read=NULL;
+ for (TInt i=0; i<iGetDetectedNetworks->Count(); ++i)
+ {
+ read = iGetDetectedNetworks->At(i);
+ if (read->iReqHandle == aTsyReqHandle)
+ {
+ delete read;
+ iGetDetectedNetworks->Delete(i);
+ break;
+ }
+ }
+ ReqCompleted(aTsyReqHandle,KErrCancel);
+ }
+
+RMobilePhone::TMobilePhoneNetworkMode CPhoneMobile::GetMode()
+/**
+* This method returns the current networkmode.
+* GSM is the only type of network supported in this TSY.
+*/
+
+ {
+ RMobilePhone::TMobilePhoneRegistrationStatus registrationstatus;
+ registrationstatus = iPhoneGlobals->iPhoneStatus.iRegistrationStatus;
+
+ switch (registrationstatus)
+ {
+ case RMobilePhone::ERegistrationUnknown:
+ return RMobilePhone::ENetworkModeUnknown;
+ case RMobilePhone::ERegistrationDenied:
+ case RMobilePhone::ENotRegisteredNoService:
+ case RMobilePhone::ENotRegisteredEmergencyOnly:
+ case RMobilePhone::ENotRegisteredSearching:
+ return RMobilePhone::ENetworkModeUnregistered;
+ case RMobilePhone::ERegisteredOnHomeNetwork:
+ case RMobilePhone::ERegisteredRoaming:
+ return RMobilePhone::ENetworkModeGsm;
+ default:
+ return RMobilePhone::ENetworkModeUnknown;
+ }
+
+ }