diff -r 000000000000 -r 3553901f7fa8 telephonyserver/etelmultimode/CETEL/mm_retrieve.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/telephonyserver/etelmultimode/CETEL/mm_retrieve.cpp Tue Feb 02 01:41:59 2010 +0200 @@ -0,0 +1,2313 @@ +// Copyright (c) 2000-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: +// This file contains all the code for the retrieval classes defined in the api which +// retrieve variable length buffers from the TSY, such as Sms messages or list of detected +// networks +// +// + +/** + @file +*/ + +// Multimode header files +#include +#include +#include +#include +#include "mm_hold.h" + + +EXPORT_C void CAsyncRetrieveVariableLengthBuffer::Start(TRequestStatus& /*aReqStatus*/, TDes8* /*aPhase1Request*/, TDes8* /*aPhase2Request*/) + { + PanicClient(EEtelPanicInvalidRequestType); + } + +EXPORT_C void CAsyncRetrieveVariableLengthBuffer::DoCancel() +/** + * This method cancels the active phase of the retrieval + * It is called from the CActive::Cancel() method + * + * @capability ReadDeviceData + * @capability NetworkServices +*/ + { + } + +EXPORT_C void CAsyncRetrieveVariableLengthBuffer::RunL() +/** + * This method processes the completion of each asynchronous phase of the retrieval + * If phase 1 is now complete, it starts phase 2 + * If phase 2 is now complete, it complete's the client's request + * + * @capability None +*/ + { + } + +EXPORT_C TBool CAsyncRetrieveVariableLengthBuffer::CompleteIfInUse(TRequestStatus& /*aReqStatus*/) + { + return EFalse; + } + + +EXPORT_C void CAsyncRetrieveVariableLengthBuffer::FreeBuffer() +/** + * This method deallocates the buffer used to hold the retrieved data + * + * @capability None +*/ + { + } + +/***********************************************************************************/ +// +// base class for buffer retrieval which require client ids to be sent to tsy +// +/***********************************************************************************/ + + +CAsyncRetrieveWithClientIds::CAsyncRetrieveWithClientIds(TInt aSessionHandle, TInt aSubSessionHandle) + { + iId().iSessionHandle = aSessionHandle; + iId().iSubSessionHandle = aSubSessionHandle; + } + +/***********************************************************************************/ +// +// base class for list retrieval from RMobilePhoneStore +// +/***********************************************************************************/ + +CAsyncRetrieveStoreList::CAsyncRetrieveStoreList(RMobilePhoneStore& aStore) : + CAsyncRetrieveWithClientIds(aStore.SessionHandle().Handle(), aStore.SubSessionHandle()), + iStore(aStore) +/** Construction of the list. + +@param aStore The Mobile phone store class that is associated with this list. */ + { + iIpcPhase1=EMobilePhoneStoreReadAllPhase1; + iIpcPhase2=EMobilePhoneStoreReadAllPhase2; + iIpcCancel=EMobilePhoneStoreReadAllCancel; + } + +CAsyncRetrieveStoreList::~CAsyncRetrieveStoreList() + { + Cancel(); + } + +void CAsyncRetrieveStoreList::Get(TInt aIpc, TRequestStatus& aReqStatus, TDes8& aDes1, TDes8& aDes2) +/** This function member uses the Get IPC request within RTelSubSessionBase to +send one of the asynchronous phase requests to ETel server. + +@param aIpc The IPC value of the asynchronous phase request. +@param aReqStatus On return, the request status for the asynchronous phase +request. +@param aDes1 The first parameter for the asynchronous phase request. +@param aDes2 The second parameter for the asynchronous phase request. */ + { + iStore.Get(aIpc,aReqStatus,aDes1,aDes2); + } + +void CAsyncRetrieveStoreList::CancelReq(TInt aIpc1, TInt aIpc2) +/** This function member cancels a previously issued Get() requests. + +@param aIpc1 The IPC value of the cancel request. +@param aIpc2 The IPC value of the original asynchronous phase request. */ + { + iStore.CancelReq(aIpc1,aIpc2); + } + +/***********************************************************************************/ +// +// base class for list retrieval from RMobilePhone +// +/***********************************************************************************/ + +EXPORT_C CAsyncRetrievePhoneList::CAsyncRetrievePhoneList(RMobilePhone& aPhone) : + CAsyncRetrieveWithClientIds(aPhone.SessionHandle().Handle(), aPhone.SubSessionHandle()), + iPhone(aPhone) +/** Contruct the list for RMobilePhone aPhone. + +@param aPhone The phone class that will be used to retrieve the lists. */ + { + } + +EXPORT_C CAsyncRetrievePhoneList::~CAsyncRetrievePhoneList() + { + Cancel(); + } + +EXPORT_C void CAsyncRetrievePhoneList::Get(TInt aIpc, TRequestStatus& aReqStatus, TDes8& aDes1, TDes8& aDes2) +/** This function member uses the Get IPC request within RTelSubsessionBase to +send one of the asynchronous phase requests to ETel server. + +@param aIpc The IPC value of the asynchronous phase request. +@param aReqStatus On return, the request status for the asynchronous phase +request. +@param aDes1 The first parameter for the asynchronous phase request. +@param aDes2 The second parameter for the asynchronous phase request. +*/ + { + iPhone.Get(aIpc,aReqStatus,aDes1,aDes2); + } + +EXPORT_C void CAsyncRetrievePhoneList::CancelReq(TInt aIpc1, TInt aIpc2) +/** This function member uses the Cancel IPC request within RTelSubsessionBase +to send a cancel for one of the asynchronous phases to ETel server. + +@param aIpc1 The IPC value of the cancel request. +@param aIpc2 The IPC value of the original asynchronous phase request. + +@capability NetworkServices +@capability ReadDeviceData +*/ + { + iPhone.CancelReq(aIpc1,aIpc2); + } + + +/***********************************************************************************/ +// +// Retrieve a list of detected networks +// +/***********************************************************************************/ + +EXPORT_C CRetrieveMobilePhoneDetectedNetworks* CRetrieveMobilePhoneDetectedNetworks::NewL(RMobilePhone& aPhone) +/** This function member creates an instance of the CRetrieveMobilePhoneDetectedNetworks +class. + +@param aPhone A reference to their RMobilePhone sub-session as it is this +sub-session that the list retrieval class will operate on. +@return The newly created CRetrieveMobilePhoneDetectedNetworks class. +@capability None +*/ + { + CRetrieveMobilePhoneDetectedNetworks* r=new(ELeave) CRetrieveMobilePhoneDetectedNetworks(aPhone); + CleanupStack::PushL(r); + r->ConstructL(); + CleanupStack::Pop(); + return r; + } + +CRetrieveMobilePhoneDetectedNetworks::CRetrieveMobilePhoneDetectedNetworks(RMobilePhone& aPhone) +: CAsyncRetrievePhoneList(aPhone), iListExtensionId(KETelExtMultimodeV1) + { + } + +void CRetrieveMobilePhoneDetectedNetworks::ConstructL() + { + iIpcPhase1=EMobilePhoneGetDetectedNetworksPhase1; + iIpcPhase2=EMobilePhoneGetDetectedNetworksPhase2; + iIpcCancel=EMobilePhoneGetDetectedNetworksCancel; + } + +EXPORT_C CRetrieveMobilePhoneDetectedNetworks::~CRetrieveMobilePhoneDetectedNetworks() +/** The destructor frees all resources owned by the object, prior to its destruction. */ + { + delete iResults; + delete iResultsV2; + delete iResultsV5; + delete iResultsV8; + + } + +EXPORT_C CMobilePhoneNetworkList* CRetrieveMobilePhoneDetectedNetworks::RetrieveListL() +/** This function member provides the client with a handle to the list class retrieved +from the phone. The client will call this function member once Start() has +completed. + +When the client calls this function member the ownership of the CMobilePhoneNetworkList +object will transfer to the client, so the client is then responsible for +eventual deletion of this object. + +@leave KErrNotFound If there is no valid list object to return to the client. +@return A handle to the list class retrieved from the store. If there are no entries in +the list then a handle to an empty list is returned. +@capability None +*/ + { + if (iResults) + { + // Give ownership of list to caller of this method + CMobilePhoneNetworkList* ptr=iResults; + iResults=NULL; + return ptr; + } + else + { + User::Leave(KErrNotFound); + return NULL; + } + } + +EXPORT_C CMobilePhoneNetworkListV2* CRetrieveMobilePhoneDetectedNetworks::RetrieveListV2L() +/** This function member provides the client with a handle to the CMobilePhoneNetworkListV2 +list class retrieved from the phone. The client will call this function member once +StartV2() has completed. + +When the client calls this function member the ownership of the CMobilePhoneNetworkListV2 +object will transfer to the client, so the client is then responsible for +eventual deletion of this object. + +@leave KErrNotFound If there is no valid list object to return to the client. +@return A handle to the list class retrieved from the store. If there are no entries in +the list then a handle to an empty list is returned. +@capability None +*/ + { + if (iResultsV2) + { + // Give ownership of list to caller of this method + CMobilePhoneNetworkListV2* ptr=iResultsV2; + iResultsV2=NULL; + return ptr; + } + else + { + User::Leave(KErrNotFound); + return NULL; + } + } + +EXPORT_C CMobilePhoneNetworkListV5* CRetrieveMobilePhoneDetectedNetworks::RetrieveListV5L() +/** This function member provides the client with a handle to the CMobilePhoneNetworkListV5 +list class retrieved from the phone. The client will call this function member once +StartV5() has completed. + +When the client calls this function member the ownership of the CMobilePhoneNetworkListV5 +object will transfer to the client, so the client is then responsible for +eventual deletion of this object. + +@leave KErrNotFound If there is no valid list object to return to the client. +@return A handle to the list class retrieved from the store. If there are no entries in +the list then a handle to an empty list is returned. +@capability None +*/ + { + if (iResultsV5) + { + // Give ownership of list to caller of this method + CMobilePhoneNetworkListV5* ptr=iResultsV5; + iResultsV5=NULL; + return ptr; + } + else + { + User::Leave(KErrNotFound); + return NULL; + } + } + +EXPORT_C CMobilePhoneNetworkListV8* CRetrieveMobilePhoneDetectedNetworks::RetrieveListV8L() +/** This function member provides the client with a handle to the CMobilePhoneNetworkListV8 +list class retrieved from the phone. The client will call this function member once +StartV8() has completed. + +When the client calls this function member the ownership of the CMobilePhoneNetworkListV8 +object will transfer to the client, so the client is then responsible for +eventual deletion of this object. + +@leave KErrNotFound If there is no valid list object to return to the client. +@return A handle to the list class retrieved from the store. If there are no entries in +the list then a handle to an empty list is returned. +@capability None +*/ + { + if (iResultsV8) + { + // Give ownership of list to caller of this method + CMobilePhoneNetworkListV8* ptr=iResultsV8; + iResultsV8=NULL; + return ptr; + } + else + { + User::Leave(KErrNotFound); + return NULL; + } + } + +EXPORT_C void CRetrieveMobilePhoneDetectedNetworks::Start(TRequestStatus& aReqStatus) +/** This function member starts the two-phase list retrieval of detected networks. + +@param aReqStatus On completion, the status of the request; KErrNone if successful, +KErrNotSupported if the phone does not support access to a detected network +store and KErrNotFound if the store does not exist. If the list is empty then KErrNone +is returned. +@capability NetworkServices +@capability ReadDeviceData +*/ + { + if (!CompleteIfInUse(aReqStatus)) + { + iIpcPhase1=EMobilePhoneGetDetectedNetworksPhase1; + iIpcPhase2=EMobilePhoneGetDetectedNetworksPhase2; + iIpcCancel=EMobilePhoneGetDetectedNetworksCancel; + iListExtensionId = KETelExtMultimodeV1; + + delete iResults; + iResults = NULL; + CAsyncRetrieveVariableLengthBufferV2::Start(aReqStatus,&iId,&iId); + } + } + +EXPORT_C void CRetrieveMobilePhoneDetectedNetworks::StartV2(TRequestStatus& aReqStatus) +/** This function member starts the two-phase list retrieval of detected networks. + +@param aReqStatus On completion, the status of the request; KErrNone if successful, +KErrNotSupported if the phone does not support access to a detected network +store and KErrNotFound if the store does not exist. If the list is empty then KErrNone +is returned. +@capability NetworkServices +@capability ReadDeviceData +*/ + { + if (!CompleteIfInUse(aReqStatus)) + { + iIpcPhase1=EMobilePhoneGetDetectedNetworksV2Phase1; + iIpcPhase2=EMobilePhoneGetDetectedNetworksV2Phase2; + iIpcCancel=EMobilePhoneGetDetectedNetworksV2Cancel; + iListExtensionId = KETelExtMultimodeV2; + + delete iResultsV2; + iResultsV2 = NULL; + CAsyncRetrieveVariableLengthBufferV2::Start(aReqStatus,&iId,&iId); + } + } + +EXPORT_C void CRetrieveMobilePhoneDetectedNetworks::StartV5(TRequestStatus& aReqStatus) +/** This function member starts the two-phase list retrieval of detected networks. + +@param aReqStatus On completion, the status of the request; KErrNone if successful, +KErrNotSupported if the phone does not support access to a detected network +store and KErrNotFound if the store does not exist. If the list is empty then KErrNone +is returned. +@capability NetworkServices +@capability ReadDeviceData +*/ + { + if (!CompleteIfInUse(aReqStatus)) + { + iIpcPhase1=EMobilePhoneGetDetectedNetworksV5Phase1; + iIpcPhase2=EMobilePhoneGetDetectedNetworksV5Phase2; + iIpcCancel=EMobilePhoneGetDetectedNetworksV5Cancel; + iListExtensionId = KEtelExtMultimodeV5; + + delete iResultsV5; + iResultsV5 = NULL; + CAsyncRetrieveVariableLengthBufferV2::Start(aReqStatus,&iId,&iId); + } + } + +EXPORT_C void CRetrieveMobilePhoneDetectedNetworks::StartV8(TRequestStatus& aReqStatus) +/** This function member starts the two-phase list retrieval of detected networks. + +@param aReqStatus On completion, the status of the request; KErrNone if successful, +KErrNotSupported if the phone does not support access to a detected network +store and KErrNotFound if the store does not exist. If the list is empty then KErrNone +is returned. +@capability NetworkServices +@capability ReadDeviceData +*/ + { + if (!CompleteIfInUse(aReqStatus)) + { + iIpcPhase1=EMobilePhoneGetDetectedNetworksV8Phase1; + iIpcPhase2=EMobilePhoneGetDetectedNetworksV8Phase2; + iIpcCancel=EMobilePhoneGetDetectedNetworksV8Cancel; + iListExtensionId = KEtelExtMultimodeV8; + + delete iResultsV8; + iResultsV8 = NULL; + CAsyncRetrieveVariableLengthBufferV2::Start(aReqStatus,&iId,&iId); + } + } + +void CRetrieveMobilePhoneDetectedNetworks::RestoreListL() +/** + * This method restores a list from a buffer that contains the streamed version of the list + */ + { + if(iListExtensionId == KETelExtMultimodeV1) + { + iResults=CMobilePhoneNetworkList::NewL(); + iResults->RestoreL(iResultsPtr); + FreeBuffer(); + } + else if(iListExtensionId == KETelExtMultimodeV2) + { + iResultsV2=CMobilePhoneNetworkListV2::NewL(); + iResultsV2->RestoreL(iResultsPtr); + FreeBuffer(); + } + else if(iListExtensionId == KEtelExtMultimodeV5) + { + iResultsV5=CMobilePhoneNetworkListV5::NewL(); + iResultsV5->RestoreL(iResultsPtr); + FreeBuffer(); + } + else if(iListExtensionId == KEtelExtMultimodeV8) + { + iResultsV8=CMobilePhoneNetworkListV8::NewL(); + iResultsV8->RestoreL(iResultsPtr); + FreeBuffer(); + } + else + { + User::Leave(KErrNotFound); + } + + } + + +/***********************************************************************************/ +// +// Retrieve a list of call forwarding status/info +// +/***********************************************************************************/ + +EXPORT_C CRetrieveMobilePhoneCFList* CRetrieveMobilePhoneCFList::NewL(RMobilePhone& aPhone) +/** This member function creates an instance of the CRetrieveMobilePhoneCFList +class. + +@param aPhone A reference to the RMobilePhone sub-session as it is this sub-session +that the list retrieval class will operate on. +@return A pointer to the newly created CRetrieveMobilePhoneCFList object. +*/ + { + CRetrieveMobilePhoneCFList* r=new(ELeave) CRetrieveMobilePhoneCFList(aPhone); + CleanupStack::PushL(r); + r->ConstructL(); + CleanupStack::Pop(); + return r; + } + +CRetrieveMobilePhoneCFList::CRetrieveMobilePhoneCFList(RMobilePhone& aPhone) : + CAsyncRetrievePhoneList(aPhone) + { + } + +void CRetrieveMobilePhoneCFList::ConstructL() + { + iIpcPhase1=EMobilePhoneGetCallForwardingStatusPhase1; + iIpcPhase2=EMobilePhoneGetCallForwardingStatusPhase2; + iIpcCancel=EMobilePhoneGetCallForwardingStatusCancel; + } + +EXPORT_C CRetrieveMobilePhoneCFList::~CRetrieveMobilePhoneCFList() +/** The destructor frees all resources owned by the object, prior to its destruction. */ + { + delete iResults; + } + +EXPORT_C CMobilePhoneCFList* CRetrieveMobilePhoneCFList::RetrieveListL() +/** This member function provides the client with a handle to the list class retrieved +from the phone. The client will call this member function once Start() has +completed. The retrieved list will consist of an entry per basic service group +per specified CF condition. When the client calls this member function the +ownership of the CMobilePhoneCFList object will transfer to the client, so +the client is then responsible for eventual deletion of this object. + +@leave KErrNotFound If there is no valid list object to return to the client. +@return A handle to the list class retrieved from the store. If there are no entries in +the list then a handle to an empty list is returned. +*/ + { + if (iResults) + { + // Give ownership of list to caller of this method + CMobilePhoneCFList* ptr=iResults; + iResults=NULL; + return ptr; + } + else + { + User::Leave(KErrNotFound); + return NULL; + } + } + +EXPORT_C void CRetrieveMobilePhoneCFList::Start(TRequestStatus& aReqStatus, + RMobilePhone::TMobilePhoneCFCondition aCondition, + RMobilePhone::TMobileInfoLocation aLocation) +/** + * This method starts the retrieval of the call forwarding status list + * + * @deprecated 7.0s. + * Deprecated, other CRetrieveMobilePhoneCFList::Start overload should be used instead + * @capability NetworkServices + * @capability ReadDeviceData + */ + { + if (!CompleteIfInUse(aReqStatus)) + { + delete iResults; + iResults = NULL; + + iCFRequestData().iCondition=aCondition; + iCFRequestData().iLocation=aLocation; + iCFRequestData().iClient=iId(); + iCFRequestData().iServiceGroup=RMobilePhone::EAllServices; + + CAsyncRetrievePhoneList::Start(aReqStatus,&iCFRequestData,&iId); + } + } + +EXPORT_C void CRetrieveMobilePhoneCFList::Start(TRequestStatus& aReqStatus, + RMobilePhone::TMobilePhoneCFCondition aCondition, + RMobilePhone::TMobileService aServiceGroup, + RMobilePhone::TMobileInfoLocation aLocation + ) +/** + * This method starts the retrieval of the call forwarding status list. + * If the list is empty then KErrNone is returned. + * @capability NetworkServices + * @capability ReadDeviceData + */ + { + if (!CompleteIfInUse(aReqStatus)) + { + + delete iResults; + iResults = NULL; + + iCFRequestData().iCondition=aCondition; + iCFRequestData().iLocation=aLocation; + iCFRequestData().iClient=iId(); + iCFRequestData().iServiceGroup=aServiceGroup; + + CAsyncRetrievePhoneList::Start(aReqStatus,&iCFRequestData,&iId); + } + } + +void CRetrieveMobilePhoneCFList::RestoreListL() +/** + * This method restores a list from a buffer that contains the streamed version of the list + */ + { + iResults=CMobilePhoneCFList::NewL(); + iResults->RestoreL(iResultsPtr); + FreeBuffer(); + } + +/***********************************************************************************/ +// +// Retrieve a list of call barring status/info +// +/***********************************************************************************/ + +EXPORT_C CRetrieveMobilePhoneCBList* CRetrieveMobilePhoneCBList::NewL(RMobilePhone& aPhone) +/** This member function creates an instance of the CRetrieveMobilePhoneCBList +class. + +@param aPhone A reference to the RMobilePhone sub-session, as it is this sub-session +that the list retrieval class will operate on. +@return A pointer to the newly created CRetrieveMobilePhoneCBList object. +@capability None +*/ + { + CRetrieveMobilePhoneCBList* r=new(ELeave) CRetrieveMobilePhoneCBList(aPhone); + CleanupStack::PushL(r); + r->ConstructL(); + CleanupStack::Pop(); + return r; + } + +CRetrieveMobilePhoneCBList::CRetrieveMobilePhoneCBList(RMobilePhone& aPhone) : + CAsyncRetrievePhoneList(aPhone), iListExtensionId(KETelExtMultimodeV1) + { + } + +void CRetrieveMobilePhoneCBList::ConstructL() + { + } + +EXPORT_C CRetrieveMobilePhoneCBList::~CRetrieveMobilePhoneCBList() +/** The destructor frees all resources owned by the object, prior to its destruction. */ + { + delete iResults; + } + +EXPORT_C CMobilePhoneCBList* CRetrieveMobilePhoneCBList::RetrieveListL() +/** This member function provides the client with a handle to the list class retrieved +from the phone. + +The client will call this member function once Start() has completed. The +retrieved list will consist of an entry per basic service group per specified +CB condition. + +When the client calls this member function the ownership of the CMobilePhoneCBList +object will transfer to the client, so the client is then responsible for +eventual deletion of this object. + +@leave KErrNotFound If there is no valid list object to return to the client. +@return A handle to the list class retrieved from the store. If there are no entries in +the list then a handle to an empty list is returned. +@capability ReadDeviceData +*/ + { + if (iResults) + { + // Give ownership of list to caller of this method + CMobilePhoneCBList* ptr=iResults; + iResults=NULL; + return ptr; + } + else + { + User::Leave(KErrNotFound); + return NULL; + } + } + + + +EXPORT_C void CRetrieveMobilePhoneCBList::Start(TRequestStatus& aReqStatus, + RMobilePhone::TMobilePhoneCBCondition aCondition, + RMobilePhone::TMobileInfoLocation aLocation) +/** This member function starts the two-phase list retrieval. The client also specifies +the call barring condition(s) that it wants to interrogate and from where +this information should be retrieved. The client then waits for its request +to be completed. + +@param aReqStatus On completion, the status of the request; KErrNone if successful, +KErrNotSupported if the phone does not support access to a CB list store and +KErrNotFound if the store does not exist. If the list is empty then KErrNone +is returned. +@param aCondition The barring conditions to interrogate. +@param aLocation Specifies from where this information should be retrieved. +This parameters defaults to: RMobilePhone::EInfoLocationCachePreferred. +@capability NetworkServices +@capability ReadDeviceData +*/ + { + if (!CompleteIfInUse(aReqStatus)) + { + + iIpcPhase1 = EMobilePhoneGetBarringStatusPhase1; + iIpcPhase2 = EMobilePhoneGetBarringStatusPhase2; + iIpcCancel = EMobilePhoneGetBarringStatusCancel; + iListExtensionId = KETelExtMultimodeV1; + + delete iResults; + iResults = NULL; + + iCBRequestData().iCondition=aCondition; + iCBRequestData().iLocation=aLocation; + iCBRequestData().iClient=iId(); + + CAsyncRetrievePhoneList::Start(aReqStatus,&iCBRequestData,&iId); + } + } + + +void CRetrieveMobilePhoneCBList::RestoreListL() +/** + * This method restores a list from a buffer that contains the streamed version of the list + */ + { + if(iListExtensionId == KETelExtMultimodeV1) + { + iResults=CMobilePhoneCBList::NewL(); + iResults->RestoreL(iResultsPtr); + FreeBuffer(); + } + else + User::Leave(KErrNotFound); + } + +/***********************************************************************************/ +// +// Retrieve a list of call waiting status/info +// +/***********************************************************************************/ + +EXPORT_C CRetrieveMobilePhoneCWList* CRetrieveMobilePhoneCWList::NewL(RMobilePhone& aPhone) +/** This function member creates an instance of the CRetrieveMobilePhoneCWList +class. + +@param aPhone A reference to the RMobilePhone sub-session as this is the sub-session +that the list retrieval class will operate on. +@return A pointer to the newly created CRetrieveMobilePhoneCWList object. +@capability None +*/ + { + CRetrieveMobilePhoneCWList* r=new(ELeave) CRetrieveMobilePhoneCWList(aPhone); + CleanupStack::PushL(r); + r->ConstructL(); + CleanupStack::Pop(); + return r; + } + +CRetrieveMobilePhoneCWList::CRetrieveMobilePhoneCWList(RMobilePhone& aPhone) : + CAsyncRetrievePhoneList(aPhone) + { + } + +void CRetrieveMobilePhoneCWList::ConstructL() + { + iIpcPhase1=EMobilePhoneGetWaitingStatusPhase1; + iIpcPhase2=EMobilePhoneGetWaitingStatusPhase2; + iIpcCancel=EMobilePhoneGetWaitingStatusCancel; + } + +EXPORT_C CRetrieveMobilePhoneCWList::~CRetrieveMobilePhoneCWList() +/** The destructor frees all resources owned by the object, prior to its destruction. */ + { + delete iResults; + } + +EXPORT_C CMobilePhoneCWList* CRetrieveMobilePhoneCWList::RetrieveListL() +/** This function member provides the client with a handle to the list class retrieved +from the phone. The client will call this function member once Start() has +completed. + +When the client calls this function member the ownership of the CMobilePhoneCWList +object will transfer to the client, so the client is then responsible for +eventual deletion of this object. + +@leave KErrNotFound If there is no valid list object to return to the client +@return A handle to the list class retrieved from the store. If there are no entries in +the list then a handle to an empty list is returned. +@capability ReadDeviceData +*/ + { + if (iResults) + { + // Give ownership of list to caller of this method + CMobilePhoneCWList* ptr=iResults; + iResults=NULL; + return ptr; + } + else + { + User::Leave(KErrNotFound); + return NULL; + } + } + +EXPORT_C void CRetrieveMobilePhoneCWList::Start(TRequestStatus& aReqStatus, + RMobilePhone::TMobileInfoLocation aLocation) +/** This function member starts the two-phase list retrieval. + +@param aReqStatus On completion, the status of the request; KErrNone if successful, +KErrNotSupported if the phone does not support access to a call waiting list +store and KErrNotFound if the store does not exist. If the list is empty then KErrNone +is returned. +@param aLocation Specifies from where this information should be retrieved. +Defaults to RMobilePhone::EInfoLocationCachePreferred +@capability NetworkServices +@capability ReadDeviceData +*/ + { + if (!CompleteIfInUse(aReqStatus)) + { + delete iResults; + iResults = NULL; + + iCWRequestData().iLocation=aLocation; + iCWRequestData().iClient=iId(); + + CAsyncRetrievePhoneList::Start(aReqStatus,&iCWRequestData,&iId); + } + } + +void CRetrieveMobilePhoneCWList::RestoreListL() +/** + * This method restores a list from a buffer that contains the streamed version of the list + */ + { + iResults=CMobilePhoneCWList::NewL(); + iResults->RestoreL(iResultsPtr); + FreeBuffer(); + } + + +/***********************************************************************************/ +// +// Retrieve a list of call completion Requests +// +/***********************************************************************************/ + +EXPORT_C CRetrieveMobilePhoneCcbsList* CRetrieveMobilePhoneCcbsList::NewL(RMobilePhone& aPhone) +/** This member function creates an instance of the CRetrieveMobilePhoneCcbsList +class. + +@param aPhone A reference to the RMobilePhone sub-session, as it is this sub-session +that the list retrieval class will operate on. +@return A pointer to the newly created CRetrieveMobilePhoneCcbsList object. +@capability None +*/ + { + CRetrieveMobilePhoneCcbsList* r=new(ELeave) CRetrieveMobilePhoneCcbsList(aPhone); + CleanupStack::PushL(r); + r->ConstructL(); + CleanupStack::Pop(); + return r; + } + +CRetrieveMobilePhoneCcbsList::CRetrieveMobilePhoneCcbsList(RMobilePhone& aPhone) : + CAsyncRetrievePhoneList(aPhone) + { + } + +void CRetrieveMobilePhoneCcbsList::ConstructL() + { + iIpcPhase1=EMobilePhoneGetCompletionRequestsPhase1; + iIpcPhase2=EMobilePhoneGetCompletionRequestsPhase2; + iIpcCancel=EMobilePhoneGetCompletionRequestsCancel; + } + +EXPORT_C CRetrieveMobilePhoneCcbsList::~CRetrieveMobilePhoneCcbsList() +/** The destructor frees all resources owned by the object, prior to its destruction. */ + { + delete iResults; + } + +EXPORT_C CMobilePhoneCcbsList* CRetrieveMobilePhoneCcbsList::RetrieveListL() +/** This member function provides the client with a handle to the list class retrieved +from the phone. The client will call this member function once Start() has +completed. + +When the client calls this member function the ownership of the CMobilePhoneCcbsList +object will transfer to the client, so the client is then responsible for +eventual deletion of this object. + +@leave KErrNotFound If there is no valid list object to return to the client. +@return A handle to the list class retrieved from the store. If there are no entries in +the list then a handle to an empty list is returned. +@capability ReadDeviceData +*/ + { + if (iResults) + { + // Give ownership of list to caller of this method + CMobilePhoneCcbsList* ptr=iResults; + iResults=NULL; + return ptr; + } + else + { + User::Leave(KErrNotFound); + return NULL; + } + } + +EXPORT_C void CRetrieveMobilePhoneCcbsList::Start(TRequestStatus& aReqStatus) +/** This member function starts the two-phase list retrieval. + +@param aReqStatus On completion, the status of the request; KErrNone if successful, +KErrNotSupported if the phone does not support access to a CCBS list store +and KErrNotFound if the store does not exist. If the list is empty then KErrNone +is returned. +@capability NetworkServices +@capability ReadDeviceData +*/ + { + if (!CompleteIfInUse(aReqStatus)) + { + delete iResults; + iResults = NULL; + + CAsyncRetrievePhoneList::Start(aReqStatus,&iId,&iId); + } + } + +void CRetrieveMobilePhoneCcbsList::RestoreListL() +/** + * This method restores a list from a buffer that contains the streamed version of the list + */ + { + iResults=CMobilePhoneCcbsList::NewL(); + iResults->RestoreL(iResultsPtr); + FreeBuffer(); + } + +/***********************************************************************************/ +// +// Retrieve a list of SMS messages from a phone-side SMS store +// +/***********************************************************************************/ + +EXPORT_C CRetrieveMobilePhoneSmsList* CRetrieveMobilePhoneSmsList::NewL(RMobilePhoneStore& aStore, RMobileSmsStore::TMobileSmsEntryExtensionId aType) +/** This function member creates an instance of the CActive derived CRetrieveMobilePhoneSmsList +class. + +@param aStore An instance of RMobileSmsStore as this store that the list retrieval +class will operate on. +@param aType Specifies whether GSM or CDMA message store entries will be retrieved. +@return The newly created CRetrieveMobilePhoneSmsList class. +@capability None +*/ + { + CRetrieveMobilePhoneSmsList* r=new(ELeave) CRetrieveMobilePhoneSmsList(aStore, aType); + CleanupStack::PushL(r); + r->ConstructL(); + CleanupStack::Pop(); + return r; + } + +CRetrieveMobilePhoneSmsList::CRetrieveMobilePhoneSmsList(RMobilePhoneStore& aStore, RMobileSmsStore::TMobileSmsEntryExtensionId aType) +: CAsyncRetrieveStoreList(aStore), iEntryType(aType) + { + } + +void CRetrieveMobilePhoneSmsList::ConstructL() + { + } + +EXPORT_C CRetrieveMobilePhoneSmsList::~CRetrieveMobilePhoneSmsList() +/** The destructor frees all resources owned by the object, prior to its destruction. */ + { + delete iGsmResults; + delete iCdmaResults; + } + +EXPORT_C CMobilePhoneGsmSmsList* CRetrieveMobilePhoneSmsList::RetrieveGsmListL() +/** These function members will provide the client with a handle to the appropriate +GSM list class retrieved from the store. + +The client will call this function member once Start() has completed. + +When the client calls this function member the ownership of the list object +will transfer to the client, so the client is then responsible for eventual +deletion of this object. + +@leave KErrNotFound If there is no valid list object to return to the client. +@return A handle to the list class retrieved from the store. If there are no entries in +the list then a handle to an empty list is returned. +@capability ReadUserData +*/ + { + if ((iEntryType==RMobileSmsStore::KETelMobileGsmSmsEntryV1) && iGsmResults) + { + // Give ownership of GSM SMS list to caller of this method + CMobilePhoneGsmSmsList* ptr=iGsmResults; + iGsmResults=NULL; + return ptr; + } + else + { + User::Leave(KErrNotFound); + return NULL; + } + } + +EXPORT_C CMobilePhoneCdmaSmsList* CRetrieveMobilePhoneSmsList::RetrieveCdmaListL() +/** These function members will provide the client with a handle to the appropriate +CDMA list class retrieved from the store. + +The client will call this function member once Start() has completed. + +When the client calls this function member the ownership of the list object +will transfer to the client, so the client is then responsible for eventual +deletion of this object. + +@leave KErrNotFound If there is no valid list object to return to the client. +@return A handle to the list class retrieved from the store. If there are no entries in +the list then a handle to an empty list is returned. +@capability ReadUserData +*/ + { + if ((iEntryType==RMobileSmsStore::KETelMobileCdmaSmsEntryV1) && iCdmaResults) + { + // Give ownership of CDMA SMS list to caller of this method + CMobilePhoneCdmaSmsList* ptr=iCdmaResults; + iCdmaResults=NULL; + return ptr; + } + else + { + User::Leave(KErrNotFound); + return NULL; + } + } + +EXPORT_C void CRetrieveMobilePhoneSmsList::Start(TRequestStatus& aReqStatus) +/** This function member starts the two-phase list retrieval of all entries within +the store. + +@param aReqStatus On completion, the status of the request; KErrNone if successful, +KErrNotSupported if the phone does not support access to an SMS list store +and KErrNotFound if the store does not exist. If the list is empty then KErrNone +is returned. +@capability ReadUserData +*/ + { + InitiateRequest(aReqStatus,EFalse,KValueNotUsed,KValueNotUsed); + } + +EXPORT_C void CRetrieveMobilePhoneSmsList::StartBatch(TRequestStatus& aReqStatus, TInt aStartIndex, TInt aBatchSize) +/** This function member starts the two-phase list retrieval of a batch of entries. + +The client must supply the index (i.e. slot location) from which to start +the batch retrieval and the number of entries to retrieve in that batch. Please +note, that if the client specifies aStartIndex=X and aBatchSize=Y, the TSY +should look in slot X to start with and then continue looking in slots until +Y used entries are found (or less if the end of the store is reached). When +the client receives the batch, the slot index attribute of the last entry +in the list is not necessarily equal to aStartIndex+aBatchSize due to the +possibility of empty slots. + +@param aReqStatus On return, the status of the request; KErrNone if successful, +KErrNotSupported if the phone does not support access to an emergency number +store and KErrNotFound if the store does not exist. If the list is empty then KErrNone +is returned. +@param aStartIndex The slot where the TSY will start looking. +@param aBatchSize The number of entries the TSY will try to get. +@capability ReadUserData +*/ + { + InitiateRequest(aReqStatus,ETrue,aStartIndex,aBatchSize); + } + +void CRetrieveMobilePhoneSmsList::InitiateRequest(TRequestStatus& aReqStatus, TBool aBatch, TInt aStartIndex, TInt aBatchSize) +/** + * This method uses the base class's generic Start() method to start either reading + * the whole list or just a batch of entries + * + * @param aReqStatus returns the result code after the asynchronous call completes + * @param aBatch Specifies whether a batch or all entries is being read + * @param aStartIndex Specifies the first index of the batch + * @param aBatchSize Specifies how many entries to read after the start + */ + { + if (!CompleteIfInUse(aReqStatus)) + { + delete iGsmResults; + iGsmResults = NULL; + delete iCdmaResults; + iCdmaResults = NULL; + + iRequestData().iClient=iId(); + iRequestData().iEntryType = iEntryType; + iRequestData().iBatchRequest = aBatch; + iRequestData().iStartIndex = aStartIndex; + iRequestData().iBatchSize = aBatchSize; + CAsyncRetrieveVariableLengthBufferV2::Start(aReqStatus,&iRequestData,&iId); + } + } + +void CRetrieveMobilePhoneSmsList::RestoreListL() +/** + * This method restores a list from a buffer that contains the streamed version of the list + */ + { + if (iEntryType==RMobileSmsStore::KETelMobileGsmSmsEntryV1) + { + iGsmResults=CMobilePhoneGsmSmsList::NewL(); + iGsmResults->RestoreL(iResultsPtr); + } + else + { + iCdmaResults=CMobilePhoneCdmaSmsList::NewL(); + iCdmaResults->RestoreL(iResultsPtr); + } + FreeBuffer(); + } + +/***********************************************************************************/ +// +// Retrieve a list of SMS parameters from a phone-side SMSP store +// +/***********************************************************************************/ + +EXPORT_C CRetrieveMobilePhoneSmspList* CRetrieveMobilePhoneSmspList::NewL(RMobileSmsMessaging& aMessaging) +/** This member function creates an instance of the CActive derived CRetrieveMobilePhoneCbmiList +class. + +@param aMessaging An instance of RMobileSmsMessaging as it is this messaging +sub-session that the list retrieval class will operate on. +@return The newly created CRetrieveMobilePhoneSmspList class. +@capability None +*/ + { + CRetrieveMobilePhoneSmspList* r=new(ELeave) CRetrieveMobilePhoneSmspList(aMessaging); + CleanupStack::PushL(r); + r->ConstructL(); + CleanupStack::Pop(); + return r; + } + +CRetrieveMobilePhoneSmspList::CRetrieveMobilePhoneSmspList(RMobileSmsMessaging& aMessaging) +: CAsyncRetrieveWithClientIds(aMessaging.SessionHandle().Handle(), aMessaging.SubSessionHandle()), + iMessaging(aMessaging) + { + } + +void CRetrieveMobilePhoneSmspList::ConstructL() + { + iIpcPhase1=EMobileSmsMessagingGetSmspListPhase1; + iIpcPhase2=EMobileSmsMessagingGetSmspListPhase2; + iIpcCancel=EMobileSmsMessagingGetSmspListCancel; + } + +EXPORT_C CRetrieveMobilePhoneSmspList::~CRetrieveMobilePhoneSmspList() +/** The destructor frees all resources owned by the object, prior to its destruction. */ + { + Cancel(); + delete iResults; + } + +EXPORT_C CMobilePhoneSmspList* CRetrieveMobilePhoneSmspList::RetrieveListL() +/** This member function provides the client with a handle to the list class retrieved +from the store. The client will call this member function once Start() has +completed. + +When the client calls this member function the ownership of the CMobilePhoneSmspList +object will transfer to the client, so the client is then responsible for +eventual deletion of this object. + +@leave KErrNotFound If there is no valid list object to return to the client. +@return A handle to the list class retrieved from the store. If there are no entries in +the list then a handle to an empty list is returned. +@capability ReadDeviceData +*/ + { + if (iResults) + { + // Give ownership of list to caller of this method + CMobilePhoneSmspList* ptr=iResults; + iResults=NULL; + return ptr; + } + else + { + User::Leave(KErrNotFound); + return NULL; + } + } + +void CRetrieveMobilePhoneSmspList::RestoreListL() +/** + * This method restores a list from a buffer that contains the streamed version of the list + */ + { + iResults=CMobilePhoneSmspList::NewL(); + iResults->RestoreL(iResultsPtr); + FreeBuffer(); + } + +EXPORT_C void CRetrieveMobilePhoneSmspList::Start(TRequestStatus& aReqStatus) +/** This member function starts the two-phase list retrieval. + +@param aReqStatus On completion, the status of the request; KErrNone if successful, +KErrNotSupported if the phone does not support access to a SMSP list store +and KErrNotFound if the store does not exist. If the list is empty then KErrNone +is returned. +@capability ReadDeviceData +*/ + { + if (!CompleteIfInUse(aReqStatus)) + { + delete iResults; + iResults = NULL; + CAsyncRetrieveVariableLengthBufferV2::Start(aReqStatus,&iId,&iId); + } + } + +void CRetrieveMobilePhoneSmspList::Get(TInt aIpc, TRequestStatus& aReqStatus, TDes8& aDes1, TDes8& aDes2) +/** + * This method uses the Get IPC request within RTelSubsessionBase + * to send one of the asynchronous phase requests to ETel server + * + * @param aIpc The IPC value of the asynchronous phase request + * @param aReqStatus The request status for the asynchronous phase request + * @param aDes1 The first parameter for the asynchronous phase request + * @param aDes2 The second parameter for the asynchronous phase request + */ + { + iMessaging.Get(aIpc,aReqStatus,aDes1,aDes2); + } + +void CRetrieveMobilePhoneSmspList::CancelReq(TInt aIpc1, TInt aIpc2) +/** + * This method uses the Cancel IPC request within RTelSubsessionBase + * to send a cancel for one of the asynchronous phases to ETel server + * + * @param aIpc1 The IPC value of the cancel request + * @param aIpc2 The IPC value of the original asynchronous phase request + */ + { + iMessaging.CancelReq(aIpc1,aIpc2); + } + +/***********************************************************************************/ +// +// Retrieve a list of Broadcast ID entries from the SIM or phone +// +/***********************************************************************************/ + +EXPORT_C CRetrieveMobilePhoneBroadcastIdList* CRetrieveMobilePhoneBroadcastIdList::NewL(RMobileBroadcastMessaging& aMessaging) +/** This member function creates an instance of the CRetrieveMobilePhoneBroadcastIdList +class. + +@param aMessaging An instance of RMobileBroadcastMessaging as it is this messaging +sub-session that the list retrieval class will operate on. +@return The newly created CRetrieveMobilePhoneBroadcastIdList. +@capability None +*/ + { + CRetrieveMobilePhoneBroadcastIdList* r=new(ELeave) CRetrieveMobilePhoneBroadcastIdList(aMessaging); + CleanupStack::PushL(r); + r->ConstructL(); + CleanupStack::Pop(); + return r; + } + +CRetrieveMobilePhoneBroadcastIdList::CRetrieveMobilePhoneBroadcastIdList(RMobileBroadcastMessaging& aMessaging) : + CAsyncRetrieveWithClientIds(aMessaging.SessionHandle().Handle(), aMessaging.SubSessionHandle()), + iMessaging(aMessaging) + { + } + +void CRetrieveMobilePhoneBroadcastIdList::ConstructL() + { + iIpcPhase1=EMobileBroadcastMessagingGetIdListPhase1; + iIpcPhase2=EMobileBroadcastMessagingGetIdListPhase2; + iIpcCancel=EMobileBroadcastMessagingGetIdListCancel; + } + +EXPORT_C CRetrieveMobilePhoneBroadcastIdList::~CRetrieveMobilePhoneBroadcastIdList() +/** The destructor frees all resources owned by the object, prior to its destruction. */ + { + Cancel(); + delete iResults; + } + +EXPORT_C CMobilePhoneBroadcastIdList* CRetrieveMobilePhoneBroadcastIdList::RetrieveListL() +/** This member function provides the client with a handle to the list class retrieved +from the store. The client will call this member function once Start() has +completed with KErrNone. + +When the client calls this member function the ownership of the CMobilePhoneBroadcastIdList +object will transfer to the client, so the client is then responsible for +eventual deletion of this object. + +@leave KErrNotFound If there is no valid list object to return to the client. +@return A handle to the list class retrieved from the store. If there are no entries in +the list then a handle to an empty list is returned. +@capability ReadUserData +*/ + { + if (iResults) + { + // Give ownership of list to caller of this method + CMobilePhoneBroadcastIdList* ptr=iResults; + iResults=NULL; + return ptr; + } + else + { + User::Leave(KErrNotFound); + return NULL; + } + } + +EXPORT_C void CRetrieveMobilePhoneBroadcastIdList::Start(TRequestStatus& aReqStatus, RMobileBroadcastMessaging::TMobileBroadcastIdType aIdType) +/** This member function starts the two-phase list retrieval. + +@param aReqStatus On completion, the status of the request; KErrNone if successful, +KErrNotSupported if the phone does not support access to a phone book broadcast +id list store and KErrNotFound if the store does not exist. If the list is empty then KErrNone +is returned. +@param aIdType Specifies whether to retrieve the GSM/WCDMA list of CBMI entries +or the CDMA list of Service Category entries. +@capability ReadUserData +*/ + { + if (!CompleteIfInUse(aReqStatus)) + { + delete iResults; + iResults = NULL; + + iBroadcastIdRequestData().iIdType=aIdType; + iBroadcastIdRequestData().iClient=iId(); + CAsyncRetrieveVariableLengthBufferV2::Start(aReqStatus,&iBroadcastIdRequestData,&iId); + } + } + +void CRetrieveMobilePhoneBroadcastIdList::RestoreListL() +/** + * This method restores a list from a buffer that contains the streamed version of the list + */ + { + iResults=CMobilePhoneBroadcastIdList::NewL(); + iResults->RestoreL(iResultsPtr); + FreeBuffer(); + } + +void CRetrieveMobilePhoneBroadcastIdList::Get(TInt aIpc, TRequestStatus& aReqStatus, TDes8& aDes1, TDes8& aDes2) +/** + * This method uses the Get IPC request within RTelSubsessionBase + * to send one of the asynchronous phase requests to ETel server + * + * @param aIpc The IPC value of the asynchronous phase request + * @param aReqStatus The request status for the asynchronous phase request + * @param aDes1 The first parameter for the asynchronous phase request + * @param aDes2 The second parameter for the asynchronous phase request + */ + { + iMessaging.Get(aIpc,aReqStatus,aDes1,aDes2); + } + +void CRetrieveMobilePhoneBroadcastIdList::CancelReq(TInt aIpc1, TInt aIpc2) +/** + * This method uses the Cancel IPC request within RTelSubsessionBase + * to send a cancel for one of the asynchronous phases to ETel server + * + * @param aIpc1 The IPC value of the cancel request + * @param aIpc2 The IPC value of the original asynchronous phase request + */ + { + iMessaging.CancelReq(aIpc1,aIpc2); + } + +/***********************************************************************************/ +// +// Retrieve a list of entries from a phone-side NAM store +// The list contains entries of type RMobileNamStore::TMobileNamEntryV1 +// +/***********************************************************************************/ + +EXPORT_C CRetrieveMobilePhoneNamList* CRetrieveMobilePhoneNamList::NewL(RMobilePhoneStore& aStore) +/** This member function member creates an instance of the CRetrieveMobilePhoneNamList +class. + +@param aStore An instance of RMobileNamStore as it is this store that the +list retrieval class will operate on. +@return The newly created CRetrieveMobilePhoneNamList class. +@capability None +*/ + { + CRetrieveMobilePhoneNamList* r=new(ELeave) CRetrieveMobilePhoneNamList(aStore); + CleanupStack::PushL(r); + r->ConstructL(); + CleanupStack::Pop(); + return r; + } + +CRetrieveMobilePhoneNamList::CRetrieveMobilePhoneNamList(RMobilePhoneStore& aStore) : + CAsyncRetrieveStoreList(aStore), iListExtensionId(KETelExtMultimodeV1) + { + } + +void CRetrieveMobilePhoneNamList::ConstructL() + { + iRequestData().iClient=iId(); + } + +EXPORT_C CRetrieveMobilePhoneNamList::~CRetrieveMobilePhoneNamList() +/** The destructor frees all resources owned by the object, prior to its destruction. */ + { + delete iResults; + delete iResultsV4; + } + +EXPORT_C CMobilePhoneNamList* CRetrieveMobilePhoneNamList::RetrieveListL() +/** This function member provides the client with a handle to the list class retrieved +from the store. The client will call this function member once Start() has +completed. + +When the client calls this function member the ownership of the CMobilePhoneNamList +object will transfer to the client, so the client is then responsible for +eventual deletion of this object. + +@leave KErrNotFound if there is no valid list object to return to the client. +@return A handle to the list class retrieved from the store. If there are no entries in +the list then a handle to an empty list is returned. +@capability ReadDeviceData +*/ + { + if (iResults) + { + // Give ownership of list to caller of this method + CMobilePhoneNamList* ptr=iResults; + iResults=NULL; + return ptr; + } + else + { + User::Leave(KErrNotFound); + return NULL; + } + } + +EXPORT_C CMobilePhoneNamListV4* CRetrieveMobilePhoneNamList::RetrieveListV4L() +/** This function member provides the client with a handle to the list class retrieved +from the store. The client will call this function member once Start() has +completed. + +When the client calls this function member the ownership of the CMobilePhoneNamListV4 +object will transfer to the client, so the client is then responsible for +eventual deletion of this object. + +@leave KErrNotFound if there is no valid list object to return to the client. +@return A handle to the list class retrieved from the store. If there are no entries in +the list then a handle to an empty list is returned. +@capability ReadDeviceData +*/ + { + if (iResultsV4) + { + // Give ownership of list to caller of this method + CMobilePhoneNamListV4* ptr=iResultsV4; + iResultsV4=NULL; + return ptr; + } + else + { + User::Leave(KErrNotFound); + return NULL; + } + } + +void CRetrieveMobilePhoneNamList::RestoreListL() +/** + * This method restores a list from a buffer that contains the streamed version of the list + */ + { + if(iListExtensionId == KETelExtMultimodeV1) + { + iResults=CMobilePhoneNamList::NewL(); + iResults->RestoreL(iResultsPtr); + FreeBuffer(); + } + else if(iListExtensionId == KETelExtMultimodeV4) + { + iResultsV4=CMobilePhoneNamListV4::NewL(); + iResultsV4->RestoreL(iResultsPtr); + FreeBuffer(); + } + else + { + User::Leave(KErrNotSupported); + } + } + +EXPORT_C void CRetrieveMobilePhoneNamList::Start(TRequestStatus& aReqStatus, TInt aNamId) +/** This function member starts the two-phase list retrieval. + +@param aReqStatus On completion, the status of the request; KErrNone if successful, +KErrNotSupported if the phone does not support access to an NAM list store +and KErrNotFound if the store does not exist. If the list is empty then KErrNone +is returned. +@param aNamId The identity of the NAM that the client wishes to read. +@capability ReadDeviceData +*/ + { + if (!CompleteIfInUse(aReqStatus)) + { + iIpcPhase1=EMobilePhoneStoreReadAllPhase1; + iIpcPhase2=EMobilePhoneStoreReadAllPhase2; + iIpcCancel=EMobilePhoneStoreReadAllCancel; + iListExtensionId = KETelExtMultimodeV1; + + delete iResults; + iResults = NULL; + + iRequestData().iNamId = aNamId; + CAsyncRetrieveVariableLengthBufferV2::Start(aReqStatus,&iRequestData,&iId); + } + } + +EXPORT_C void CRetrieveMobilePhoneNamList::StartV4(TRequestStatus& aReqStatus, TInt aNamId) +/** This function member starts the two-phase list retrieval. + +@param aReqStatus On completion, the status of the request; KErrNone if successful, +KErrNotSupported if the phone does not support access to an NAM list store +and KErrNotFound if the store does not exist. If the list is empty then KErrNone +is returned. +@param aNamId The identity of the NAM that the client wishes to read. +@capability ReadDeviceData +*/ + { + if (!CompleteIfInUse(aReqStatus)) + { + iIpcPhase1=EMobilePhoneStoreReadAllV4Phase1; + iIpcPhase2=EMobilePhoneStoreReadAllV4Phase2; + iIpcCancel=EMobilePhoneStoreReadAllV4Cancel; + iListExtensionId = KETelExtMultimodeV4; + + delete iResultsV4; + iResultsV4 = NULL; + + iRequestData().iNamId = aNamId; + CAsyncRetrieveVariableLengthBufferV2::Start(aReqStatus,&iRequestData,&iId); + } + } + + +/***********************************************************************************/ +// +// Retrieve a list of entries from a phone-side Own Number store +// +/***********************************************************************************/ + +EXPORT_C CRetrieveMobilePhoneONList* CRetrieveMobilePhoneONList::NewL(RMobilePhoneStore& aStore) +/** This function member creates an instance of the CActive derived CRetrieveMobilePhoneONList +class. + +@param aStore An instance of RMobileONStore as this store that the list retrieval +class will operate on. +@return The newly created CRetrieveMobilePhoneONList class. +@capability None +*/ + { + CRetrieveMobilePhoneONList* r=new(ELeave) CRetrieveMobilePhoneONList(aStore); + CleanupStack::PushL(r); + r->ConstructL(); + CleanupStack::Pop(); + return r; + } + +CRetrieveMobilePhoneONList::CRetrieveMobilePhoneONList(RMobilePhoneStore& aStore) : + CAsyncRetrieveStoreList(aStore) + { + } + +void CRetrieveMobilePhoneONList::ConstructL() + { + } + +EXPORT_C CRetrieveMobilePhoneONList::~CRetrieveMobilePhoneONList() +/** The destructor frees all resources owned by the object, prior to its destruction. */ + { + delete iResults; + } + +EXPORT_C CMobilePhoneONList* CRetrieveMobilePhoneONList::RetrieveListL() +/** This function member provides the client with a handle to the list class retrieved +from the store. The client will call this function member once Start() has +completed. + +When the client calls this function member the ownership of the CMobilePhoneONList +object will transfer to the client, so the client is then responsible for +eventual deletion of this object. + +@leave KErrNotFound if there is no valid list object to return to the client. +@return A handle to the list class retrieved from the store. If there are no entries in +the list then a handle to an empty list is returned. +@capability ReadUserData +*/ + { + if (iResults) + { + // Give ownership of list to caller of this method + CMobilePhoneONList* ptr=iResults; + iResults=NULL; + return ptr; + } + else + { + User::Leave(KErrNotFound); + return NULL; + } + } + +void CRetrieveMobilePhoneONList::RestoreListL() +/** + * This method restores a list from a buffer that contains the streamed version of the list + */ + { + iResults=CMobilePhoneONList::NewL(); + iResults->RestoreL(iResultsPtr); + FreeBuffer(); + } + +EXPORT_C void CRetrieveMobilePhoneONList::Start(TRequestStatus& aReqStatus) +/** This function member starts the two-phase retrieval of all own numbers. + +@param aReqStatus On completion, the status of the request; KErrNone if successful, +KErrNotSupported if the phone does not support a access to an own number store +and KErrNotFound if the store does not exist. If the list is empty then KErrNone +is returned. +@capability ReadUserData +*/ + { + if (!CompleteIfInUse(aReqStatus)) + { + delete iResults; + iResults = NULL; + CAsyncRetrieveVariableLengthBufferV2::Start(aReqStatus,&iId,&iId); + } + } + +/***********************************************************************************/ +// +// Retrieve a list of entries from a phone-side Emergency Number store +// +/***********************************************************************************/ + +EXPORT_C CRetrieveMobilePhoneENList* CRetrieveMobilePhoneENList::NewL(RMobilePhoneStore& aStore) +/** This function member creates an instance of the CActive derived CRetrieveMobilePhoneENList +class. + +@param aStore An instance of RMobileENStore as it this store that the list +retrieval class will operate on. +@return The newly created CRetrieveMobilePhoneENList class. +@capability None +*/ + { + CRetrieveMobilePhoneENList* r=new(ELeave) CRetrieveMobilePhoneENList(aStore); + CleanupStack::PushL(r); + r->ConstructL(); + CleanupStack::Pop(); + return r; + } + +CRetrieveMobilePhoneENList::CRetrieveMobilePhoneENList(RMobilePhoneStore& aStore) : + CAsyncRetrieveStoreList(aStore) + { + } + +void CRetrieveMobilePhoneENList::ConstructL() + { + } + +EXPORT_C CRetrieveMobilePhoneENList::~CRetrieveMobilePhoneENList() +/** The destructor frees all resources owned by the object, prior to its destruction. */ + { + delete iResults; + } + +EXPORT_C CMobilePhoneENList* CRetrieveMobilePhoneENList::RetrieveListL() +/** This function member provides the client with a handle to the list class retrieved +from the store. The client will call this function member once Start() has +completed. + +When the client calls this function member the ownership of the CMobilePhoneENList +object will transfer to the client, so the client is then responsible for +eventual deletion of this object. + +@leave KErrNotFound if there is no valid list object to return to the client. +@return A handle to the list class retrieved from the store. If there are no entries in +the list then a handle to an empty list is returned. +@capability ReadUserData +*/ + { + if (iResults) + { + // Give ownership of list to caller of this method + CMobilePhoneENList* ptr=iResults; + iResults=NULL; + return ptr; + } + else + { + User::Leave(KErrNotFound); + return NULL; + } + } + +void CRetrieveMobilePhoneENList::RestoreListL() +/** + * This method restores a list from a buffer that contains the streamed version of the list + */ + { + iResults=CMobilePhoneENList::NewL(); + iResults->RestoreL(iResultsPtr); + FreeBuffer(); + } + +EXPORT_C void CRetrieveMobilePhoneENList::Start(TRequestStatus& aReqStatus) +/** This function member starts the two-phase retrieval of all emergency numbers. + +@param aReqStatus On completion, the status of the request; KErrNone if successful, +KErrNotSupported if the phone does not support access to an emergency number +store and KErrNotFound if the store does not exist. If the list is empty then KErrNone +is returned. +@capability ReadUserData +*/ + { + if (!CompleteIfInUse(aReqStatus)) + { + delete iResults; + iResults = NULL; + CAsyncRetrieveVariableLengthBufferV2::Start(aReqStatus,&iId,&iId); + } + } + +/***********************************************************************************/ +// +// Retrieve a list of stored network entries +// +/***********************************************************************************/ + +EXPORT_C CRetrieveMobilePhonePreferredNetworks* CRetrieveMobilePhonePreferredNetworks::NewL(RMobilePhone& aPhone) +/** +Creates an instance of the CActive derived CRetrieveMobilePhonePrefferredNetworks class + +@param aPhone Reference to clients RMobilePhone sub-session. +@return A pointer to the newly creasted CRetrieveMobilePhonePreferredNetworks object. + +@capability None +*/ + { + CRetrieveMobilePhonePreferredNetworks* r=new(ELeave) CRetrieveMobilePhonePreferredNetworks(aPhone); + CleanupStack::PushL(r); + r->ConstructL(); + CleanupStack::Pop(); + return r; + } + +CRetrieveMobilePhonePreferredNetworks::CRetrieveMobilePhonePreferredNetworks(RMobilePhone& aPhone) : + CAsyncRetrievePhoneList(aPhone) + { + } + +void CRetrieveMobilePhonePreferredNetworks::ConstructL() + { + iIpcPhase1=EMobilePhoneGetPreferredNetworksPhase1; + iIpcPhase2=EMobilePhoneGetPreferredNetworksPhase2; + iIpcCancel=EMobilePhoneGetPreferredNetworksCancel; + } + +EXPORT_C CRetrieveMobilePhonePreferredNetworks::~CRetrieveMobilePhonePreferredNetworks() +/** +Destructor +*/ + { + delete iResults; + } + +EXPORT_C CMobilePhoneStoredNetworkList* CRetrieveMobilePhonePreferredNetworks::RetrieveListL() +/** +Returns a pointer to the retrieved list. + +@return CMobilePhoneStoredNetworkList* Pointer to the detected networks list. +If there are no entries in the list then a handle to an empty list is returned. + +@capability None +*/ + { + if (iResults) + { + // Give ownership of list to caller of this method + CMobilePhoneStoredNetworkList* ptr=iResults; + iResults = NULL; + return ptr; + } + else + { + User::Leave(KErrNotFound); + return NULL; + } + } + +EXPORT_C void CRetrieveMobilePhonePreferredNetworks::Start(TRequestStatus& aReqStatus) +/** +Starts the retrieval of the stored networks list. + +@param aReqStatus Returns the result code after the asynchronous call completes. +If the list is empty then KErrNone is returned. + +@capability ReadDeviceData +*/ + { + if (!CompleteIfInUse(aReqStatus)) + { + delete iResults; + iResults = NULL; + CAsyncRetrieveVariableLengthBufferV2::Start(aReqStatus,&iId,&iId); + } + } + + +void CRetrieveMobilePhonePreferredNetworks::RestoreListL() +/** +Restores a list from a buffer that contains the streamed version of the list + */ + { + iResults=CMobilePhoneStoredNetworkList::NewL(); + iResults->RestoreL(iResultsPtr); + FreeBuffer(); + } + +// +// +// class for retrieval of authorization data +// +/***********************************************************************************/ +/** standard constructor, initialises data members and the base class*/ +CAsyncRetrieveAuthorizationInfo::CAsyncRetrieveAuthorizationInfo(RMobilePhone& aPhone,RMobilePhone::CImsAuthorizationInfoV5& aAuthInfo) +: iPhone(aPhone),iAuthInfo(aAuthInfo) + { + iId().iSessionHandle=aPhone.SessionHandle().Handle(); + iId().iSubSessionHandle=aPhone.SubSessionHandle(); + iIpcPhase1=EMobilePhoneAuthorizationInfoPhase1; + iIpcPhase2=EMobilePhoneAuthorizationInfoPhase2; + iIpcCancel=EMobilePhoneAuthorizationInfoCancel; + iAuthInfoValid=FALSE; + } +/** overload of base class virtual method, deserialize data retrieved from TSY to +provided data structure*/ +void CAsyncRetrieveAuthorizationInfo::RestoreListL() + { + iAuthInfo.InternalizeL(iResultsPtr); + iAuthInfoValid=TRUE; + FreeBuffer(); + } +/** Issues requested IPC to the ETEL/TSY */ +void CAsyncRetrieveAuthorizationInfo::Get(TInt aIpc, TRequestStatus& aReqStatus, TDes8& aDes1, TDes8& aDes2) + { + iPhone.Get(aIpc,aReqStatus,aDes1,aDes2); + } +/** Cancels previously issued request*/ +void CAsyncRetrieveAuthorizationInfo::CancelReq(TInt aIpc1, TInt aIpc2) + { + iPhone.CancelReq(aIpc1,aIpc2); + } + +/** +Indicates whether iAuthInfo data member is valid - data from ISIM/USIM retrieved + +@return Whether the authorization information is valid. +*/ +EXPORT_C TBool CAsyncRetrieveAuthorizationInfo::AuthInfoValid() const + { + return iAuthInfoValid; + } + +/** +Starts the 2 phase retrieval. + +@param aReqStatus On return, KErrNone if successful. +@capability ReadDeviceData +*/ +EXPORT_C void CAsyncRetrieveAuthorizationInfo::Start(TRequestStatus& aReqStatus) + { + if (!CompleteIfInUse(aReqStatus)) + { + iAuthInfoValid=FALSE; + iIpcPhase1=EMobilePhoneAuthorizationInfoPhase1; + iIpcPhase2=EMobilePhoneAuthorizationInfoPhase2; + iIpcCancel=EMobilePhoneAuthorizationInfoCancel; + CAsyncRetrieveVariableLengthBufferV2::Start(aReqStatus,&iId,&iId); + } + } + + +/** +Standard 2 phase constructor. + +@param aPhone Reference to an open phone object. +@param anAuthInfo On completion will contains the IMS authorization information. +@return Pointer instance.of class. +*/ +EXPORT_C CAsyncRetrieveAuthorizationInfo* CAsyncRetrieveAuthorizationInfo::NewL(RMobilePhone& aPhone,RMobilePhone::CImsAuthorizationInfoV5& aAuthInfo) + { + return new (ELeave)CAsyncRetrieveAuthorizationInfo(aPhone,aAuthInfo); + } + + +// +// +// Class for two-phased submission and retrieval of EAP packets +// +// + +/** +Creates a new two-phase retrieval object for sending an EAP packet to +a DF_EAP and receiving its response. + +@param aScEap The sub-session handle that will be used by the returned + object, for submitting requests to the server. +@param aEapRequestPckt The EAP request packet to send to the smart card + application's (and aScEap's) DF_EAP. +@return Pointer to a new CAsyncSmartCardEapAuthentication object for + use in one EAP request/response. +*/ +EXPORT_C CAsyncSmartCardEapAuthentication* CAsyncSmartCardEapAuthentication::NewL(RMobileSmartCardEap& aScEap, const TDesC8& aEapRequestPckt) + { + CAsyncSmartCardEapAuthentication* self = new(ELeave) CAsyncSmartCardEapAuthentication(aScEap); + CleanupStack::PushL(self); + self->ConstructL(aEapRequestPckt); + CleanupStack::Pop(); + return self; + } + +/** +Default constructor. Initialises the IPC values to be used in the two- +phase retrieval process. + +@param aScEap The sub-session handle that will be used by the returned + object, for submitting requests to the server. +*/ +CAsyncSmartCardEapAuthentication::CAsyncSmartCardEapAuthentication(RMobileSmartCardEap& aScEap) +: iSmartCardEap(aScEap) + { + iIpcPhase1 = EMobileSmartCardEapAuthenticationPhase1; + iIpcPhase2 = EMobileSmartCardEapAuthenticationPhase2; + iIpcCancel = EMobileSmartCardEapAuthenticationCancel; + } + +/** +Default destructor. +*/ +EXPORT_C CAsyncSmartCardEapAuthentication::~CAsyncSmartCardEapAuthentication() + { + delete iReqData; + } + +/** +Second phase constructor. Ensures memory can be allocated on the +client-side for storing a copy of the EAP request packet. + +@param aEapRequestPckt The EAP request packet to send to the smart card + application's (and aScEap's) DF_EAP. This will + be copied to this object's member data. +*/ +void CAsyncSmartCardEapAuthentication::ConstructL(const TDesC8& aEapRequestPckt) + { + iReqData = RMobileSmartCardEap::CEapAuthenticateRequestDataV6::NewL(); + iReqData->SetEapReqPacketL(aEapRequestPckt); + } + +/** +Starts the two-phase retrieval process. The process only completes +when both phases of retrieval complete (or in case of error/failure/ +cancellation). + +@param aReqStatus Returns the result code after the asynchronous call + completes. Request completion with KErrBadHandle + means the RMobileSmartCardEap sub-session handle, + given in the NewL(), has not been initialised + (RMobileSmartCardEap::InitialiseEapMethod()). + Completion with KErrInUse means the handle instance + is not the current owner of the DF_EAP. + +@see RMobileSmartCardEap::InitialiseEapMethod() +*/ +EXPORT_C void CAsyncSmartCardEapAuthentication::Start(TRequestStatus& aReqStatus) + { + if (iSmartCardEap.iSemaphore.Handle() == 0) + { + TRequestStatus* status1 = &aReqStatus; + User::RequestComplete(status1, KErrBadHandle); + return; + } + + if (!iSmartCardEap.iOwnsEapMethodLock) + { + TRequestStatus* status2 = &aReqStatus; + User::RequestComplete(status2, KErrInUse); + return; + } + + TRAPD(err, iReqData->ExternalizeL(iSmartCardEap.iMmPtrHolder->iReqAuthData)); + if (err != KErrNone) + { + TRequestStatus* status3 = &aReqStatus; + User::RequestComplete(status3, err); + return; + } + + TPtr8& ptr1 = iSmartCardEap.iMmPtrHolder->iReqAuthData; + + CAsyncRetrieveVariableLengthBufferV2::Start(aReqStatus, &ptr1, &ptr1); + } + +/** +Used to retrieve a descriptor pointing to the response data from the +DF_EAP. + +@return Reference to the descriptor of the retrieved response data. If + this method is called prior to a successful completion of + CAsyncSmartCardEapAuthentication::Start(), the descriptor will + point to NULL. +*/ +EXPORT_C TDesC8& CAsyncSmartCardEapAuthentication::RetrieveEapResponse() + { + return iResultsPtr; + } + +/** +Cancels the request specified through the sub-session this object was +created with. +*/ +void CAsyncSmartCardEapAuthentication::CancelReq(TInt aIpc1, TInt aIpc2) + { + iSmartCardEap.CancelReq(aIpc1, aIpc2); + } + +/** +Sends a request through the sub-session this object was created with. +*/ +void CAsyncSmartCardEapAuthentication::Get(TInt aIpc, TRequestStatus& aReqStatus, TDes8& aDes1, TDes8& aDes2) + { + iSmartCardEap.Get(aIpc, aReqStatus, aDes1, aDes2); + } + +// +// +// Class for two-phased retrieval of GBA NAF and MBMS MSK Authentication List +// +// + +EXPORT_C CRetrieveMobilePhoneAuthenticationIds* CRetrieveMobilePhoneAuthenticationIds::NewL(RMobilePhone& aPhone) +/** This function member creates an instance of the CActive derived CRetrieveMobilePhoneAuthenticationIds +class. + +@param aPhone An instance of RMobilePhone as this store that the list retrieval +class will operate on. +@return The newly created CRetrieveMobilePhoneAuthenticationIds class. +@capability None +*/ + { + CRetrieveMobilePhoneAuthenticationIds* r=new(ELeave) CRetrieveMobilePhoneAuthenticationIds(aPhone); + CleanupStack::PushL(r); + r->ConstructL(); + CleanupStack::Pop(); + return r; + } + +CRetrieveMobilePhoneAuthenticationIds::CRetrieveMobilePhoneAuthenticationIds(RMobilePhone& aPhone) +: CAsyncRetrievePhoneList(aPhone) + { + } + +void CRetrieveMobilePhoneAuthenticationIds::ConstructL() + { + iIpcPhase1=EMobilePhoneAuthenticationListPhase1; + iIpcPhase2=EMobilePhoneAuthenticationListPhase2; + iIpcCancel=EMobilePhoneAuthenticationListCancel; + } + + +EXPORT_C CRetrieveMobilePhoneAuthenticationIds::~CRetrieveMobilePhoneAuthenticationIds() +/** The destructor frees all resources owned by the object, prior to its destruction. + */ + { + delete iGbaNafIdResults; + delete iMbmsMskIdResults; + } + +EXPORT_C CMobilePhoneGbaNafIdList* CRetrieveMobilePhoneAuthenticationIds::RetrieveGbaListL() +/** These function members will provide the client with a handle to the appropriate +GbaNaf list class retrieved from the Authentication. + +The client will call this function member once Start() has completed. + +When the client calls this function member the ownership of the list object +will transfer to the client, so the client is then responsible for eventual +deletion of this object. + +@leave KErrNotFound If there is no valid list object to return to the client. +@return A handle to the list class retrieved from the store. If there are no entries in +the list then a handle to an empty list is returned. +@capability ReadDeviceData +*/ + { + if ((iListType==RMobilePhone::EGbaNafIdList) && iGbaNafIdResults) + { + // Give ownership of GbaNaf list to caller of this method + CMobilePhoneGbaNafIdList* ptr=iGbaNafIdResults; + iGbaNafIdResults=NULL; + return ptr; + } + else + { + User::Leave(KErrNotFound); + return NULL; + } + } + +EXPORT_C CMobilePhoneMbmsMskIdList* CRetrieveMobilePhoneAuthenticationIds::RetrieveMbmsListL() +/** These function members will provide the client with a handle to the appropriate +MBMS MSK ID list class retrieved from the Authentication. + +The client will call this function member once Start() has completed. + +When the client calls this function member the ownership of the list object +will transfer to the client, so the client is then responsible for eventual +deletion of this object. + +@leave KErrNotFound If there is no valid list object to return to the client. +@return A handle to the list class retrieved from the store. If there are no entries in +the list then a handle to an empty list is returned. +@capability ReadDeviceData +*/ + { + if ((iListType==RMobilePhone::EMbmsMskIdList) && iMbmsMskIdResults) + { + // Give ownership of MbmsMsk list to caller of this method + CMobilePhoneMbmsMskIdList* ptr=iMbmsMskIdResults; + iMbmsMskIdResults=NULL; + return ptr; + } + else + { + User::Leave(KErrNotFound); + return NULL; + } + } + +EXPORT_C void CRetrieveMobilePhoneAuthenticationIds::Start(TRequestStatus& aReqStatus,const TDesC8& aData) +/** This function member starts the two-phase list retrieval of all entries within +the store. + +@param aReqStatus On completion, the status of the request; KErrNone if successful, +KErrNotSupported if the phone does not support access to an Gba/Mbms list +and KErrNotFound if the list does not exist. If the list is empty then KErrNone +is returned. +@capability ReadDeviceData +*/ + { + if (!CompleteIfInUse(aReqStatus)) + { + TPckgBuf commandId; + commandId.Copy(aData); + iListType=commandId().iData; + + if(iListType == RMobilePhone::EGbaNafIdList || iListType == RMobilePhone::EMbmsMskIdList) + { + delete iGbaNafIdResults; + iGbaNafIdResults = NULL; + delete iMbmsMskIdResults; + iMbmsMskIdResults = NULL; + + iAuthRequestData().iClient = iId(); + iAuthRequestData().iAuthInfo=commandId(); + CAsyncRetrieveVariableLengthBufferV2::Start(aReqStatus,&iAuthRequestData,&iId); + } + else + { + TRequestStatus* status = &aReqStatus; + User::RequestComplete(status, KErrNotSupported); + } + + } + } + +void CRetrieveMobilePhoneAuthenticationIds::RestoreListL() +/** + * This method restores a list from a buffer that contains the streamed version of the list + */ + { + if (iListType==RMobilePhone::EGbaNafIdList) + { + iGbaNafIdResults=CMobilePhoneGbaNafIdList::NewL(); + iGbaNafIdResults->RestoreL(iResultsPtr); + } + + else if(iListType==RMobilePhone::EMbmsMskIdList) + { + iMbmsMskIdResults=CMobilePhoneMbmsMskIdList::NewL(); + iMbmsMskIdResults->RestoreL(iResultsPtr); + } + else + { + User::Leave(KErrNotSupported); + } + + FreeBuffer(); + } + +// +// +// Class for two-phased retrieval of Wlan SIDs list +// +// + +EXPORT_C CRetrieveMobilePhonePreferredWlanSIDs* CRetrieveMobilePhonePreferredWlanSIDs::NewL(RMobilePhone& aPhone) +/** +Creates an instance of the CActive derived CRetrieveMobilePhonePreferredWlanSIDs class + +@param aPhone Reference to clients RMobilePhone sub-session. +@return A pointer to the newly created CRetrieveMobilePhonePreferredWlanSIDs object. + +@capability None +*/ + { + CRetrieveMobilePhonePreferredWlanSIDs* r=new(ELeave) CRetrieveMobilePhonePreferredWlanSIDs(aPhone); + CleanupStack::PushL(r); + r->ConstructL(); + CleanupStack::Pop(); + return r; + } + +CRetrieveMobilePhonePreferredWlanSIDs::CRetrieveMobilePhonePreferredWlanSIDs(RMobilePhone& aPhone) : + CAsyncRetrievePhoneList(aPhone) + { + } + +void CRetrieveMobilePhonePreferredWlanSIDs::ConstructL() + { + iIpcPhase1=EMobilePhoneGetPreferredWlanSIDsPhase1; + iIpcPhase2=EMobilePhoneGetPreferredWlanSIDsPhase2; + iIpcCancel=EMobilePhoneGetPreferredWlanSIDsCancel; + } + +EXPORT_C CRetrieveMobilePhonePreferredWlanSIDs::~CRetrieveMobilePhonePreferredWlanSIDs() +/** +Destructor +*/ + { + delete iResults; + } + +EXPORT_C CMobilePhoneStoredWlanSIDList* CRetrieveMobilePhonePreferredWlanSIDs::RetrieveListL() +/** +Returns a pointer to the retrieved list. + +@leave KErrNotFound If there is no valid list object to return to the client. +@return CMobilePhoneStoredWlanSIDList Pointer to the Wlan Specific identifier list(user/Operator controlled). +If there are no entries in the list then a handle to an empty list is returned. + +@capability None +*/ + { + if (iResults) + { + // Give ownership of list to caller of this method + CMobilePhoneStoredWlanSIDList* ptr=iResults; + iResults = NULL; + return ptr; + } + else + { + User::Leave(KErrNotFound); + return NULL; + } + } + +EXPORT_C void CRetrieveMobilePhonePreferredWlanSIDs::Start(TRequestStatus& aReqStatus) +/** +Starts the retrieval of the stored Wlan Specific identifier list. + +@param aReqStatus Returns the result code after the asynchronous call completes. +If the list is empty then KErrNone is returned. + +@capability ReadDeviceData +*/ + { + if (!CompleteIfInUse(aReqStatus)) + { + delete iResults; + iResults = NULL; + CAsyncRetrieveVariableLengthBufferV2::Start(aReqStatus,&iId,&iId); + } + } + +void CRetrieveMobilePhonePreferredWlanSIDs::RestoreListL() +/** +Restores a list from a buffer that contains the streamed version of the list + */ + { + iResults=CMobilePhoneStoredWlanSIDList::NewL(); + iResults->RestoreL(iResultsPtr); + FreeBuffer(); + }