1 // Copyright (c) 2000-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // This file contains all the code for the retrieval classes defined in the api which

    15 // retrieve variable length buffers from the TSY, such as Sms messages or list of detected

    16 // networks

    17 // 

    18 //

    19 

    20 /**

    21  @file

    22 */

    23 

    24 // Multimode header files

    25 #include <etelmm.h>

    26 #include <mmretrieve.h>

    27 #include <etelext.h>

    28 #include <e32base.h>

    29 #include "mm_hold.h"

    30 	

    31 

    32 EXPORT_C void CAsyncRetrieveVariableLengthBuffer::Start(TRequestStatus& /*aReqStatus*/, TDes8* /*aPhase1Request*/, TDes8* /*aPhase2Request*/)

    33 	{

    34 	PanicClient(EEtelPanicInvalidRequestType);

    35 	}

    36 

    37 EXPORT_C void CAsyncRetrieveVariableLengthBuffer::DoCancel()

    38 /**

    39  * This method cancels the active phase of the retrieval

    40  * It is called from the CActive::Cancel() method

    41  * 

    42  * @capability ReadDeviceData

    43  * @capability NetworkServices

    44 */

    45 	{

    46 	}

    47 

    48 EXPORT_C void CAsyncRetrieveVariableLengthBuffer::RunL()

    49 /**

    50  * This method processes the completion of each asynchronous phase of the retrieval

    51  * If phase 1 is now complete, it starts phase 2

    52  * If phase 2 is now complete, it complete's the client's request

    53  *  

    54  * @capability None

    55 */

    56 	{

    57 	}

    58 

    59 EXPORT_C TBool CAsyncRetrieveVariableLengthBuffer::CompleteIfInUse(TRequestStatus& /*aReqStatus*/)

    60 	{

    61 	return EFalse;

    62 	}

    63 

    64 

    65 EXPORT_C void CAsyncRetrieveVariableLengthBuffer::FreeBuffer()

    66 /**

    67  * This method deallocates the buffer used to hold the retrieved data

    68  *  

    69  * @capability None

    70 */

    71 	{

    72 	}

    73 

    74 /***********************************************************************************/

    75 //

    76 // base class for buffer retrieval which require client ids to be sent to tsy

    77 //

    78 /***********************************************************************************/

    79 

    80 

    81 CAsyncRetrieveWithClientIds::CAsyncRetrieveWithClientIds(TInt aSessionHandle, TInt aSubSessionHandle)

    82 	{

    83 	iId().iSessionHandle = aSessionHandle;

    84 	iId().iSubSessionHandle = aSubSessionHandle;

    85 	}

    86 

    87 /***********************************************************************************/

    88 //

    89 // base class for list retrieval from RMobilePhoneStore

    90 //

    91 /***********************************************************************************/

    92 

    93 CAsyncRetrieveStoreList::CAsyncRetrieveStoreList(RMobilePhoneStore& aStore) : 

    94 	CAsyncRetrieveWithClientIds(aStore.SessionHandle().Handle(), aStore.SubSessionHandle()), 

    95 	iStore(aStore)

    96 /** Construction of the list.

    97 

    98 @param aStore The Mobile phone store class that is associated with this list. */

    99 	{

   100 	iIpcPhase1=EMobilePhoneStoreReadAllPhase1;

   101 	iIpcPhase2=EMobilePhoneStoreReadAllPhase2;

   102 	iIpcCancel=EMobilePhoneStoreReadAllCancel;

   103 	}

   104 	

   105 CAsyncRetrieveStoreList::~CAsyncRetrieveStoreList()

   106  	{	

   107  	Cancel();

   108  	}

   109 

   110 void CAsyncRetrieveStoreList::Get(TInt aIpc, TRequestStatus& aReqStatus, TDes8& aDes1, TDes8& aDes2)

   111 /** This function member uses the Get IPC request within RTelSubSessionBase to 

   112 send one of the asynchronous phase requests to ETel server.

   113 

   114 @param aIpc The IPC value of the asynchronous phase request.

   115 @param aReqStatus On return, the request status for the asynchronous phase 

   116 request.

   117 @param aDes1 The first parameter for the asynchronous phase request.

   118 @param aDes2 The second parameter for the asynchronous phase request. */

   119 	{

   120 	iStore.Get(aIpc,aReqStatus,aDes1,aDes2);

   121 	}

   122 

   123 void CAsyncRetrieveStoreList::CancelReq(TInt aIpc1, TInt aIpc2)

   124 /** This function member cancels a previously issued Get() requests.

   125 

   126 @param aIpc1 The IPC value of the cancel request.

   127 @param aIpc2 The IPC value of the original asynchronous phase request. */

   128 	{

   129 	iStore.CancelReq(aIpc1,aIpc2);

   130 	}

   131 

   132 /***********************************************************************************/

   133 //

   134 // base class for list retrieval from RMobilePhone

   135 //

   136 /***********************************************************************************/

   137 

   138 EXPORT_C CAsyncRetrievePhoneList::CAsyncRetrievePhoneList(RMobilePhone& aPhone) : 

   139 	CAsyncRetrieveWithClientIds(aPhone.SessionHandle().Handle(), aPhone.SubSessionHandle()),

   140 	iPhone(aPhone) 

   141 /** Contruct the list for RMobilePhone aPhone.

   142 

   143 @param aPhone The phone class that will be used to retrieve the lists. */

   144 	{

   145 	}

   146 

   147 EXPORT_C CAsyncRetrievePhoneList::~CAsyncRetrievePhoneList()

   148  	{

   149  	Cancel();

   150  	}

   151 

   152 EXPORT_C void CAsyncRetrievePhoneList::Get(TInt aIpc, TRequestStatus& aReqStatus, TDes8& aDes1, TDes8& aDes2)

   153 /** This function member uses the Get IPC request within RTelSubsessionBase to 

   154 send one of the asynchronous phase requests to ETel server.

   155 

   156 @param aIpc The IPC value of the asynchronous phase request.

   157 @param aReqStatus On return, the request status for the asynchronous phase 

   158 request.

   159 @param aDes1 The first parameter for the asynchronous phase request.

   160 @param aDes2 The second parameter for the asynchronous phase request. 

   161 */

   162 	{

   163 	iPhone.Get(aIpc,aReqStatus,aDes1,aDes2);

   164 	}

   165 

   166 EXPORT_C void CAsyncRetrievePhoneList::CancelReq(TInt aIpc1, TInt aIpc2)

   167 /** This function member uses the Cancel IPC request within RTelSubsessionBase 

   168 to send a cancel for one of the asynchronous phases to ETel server.

   169 

   170 @param aIpc1 The IPC value of the cancel request.

   171 @param aIpc2 The IPC value of the original asynchronous phase request. 

   172 

   173 @capability NetworkServices

   174 @capability ReadDeviceData

   175 */

   176 	{

   177 	iPhone.CancelReq(aIpc1,aIpc2);

   178 	}

   179 

   180 

   181 /***********************************************************************************/

   182 //

   183 // Retrieve a list of detected networks

   184 //

   185 /***********************************************************************************/

   186 

   187 EXPORT_C CRetrieveMobilePhoneDetectedNetworks* CRetrieveMobilePhoneDetectedNetworks::NewL(RMobilePhone& aPhone)

   188 /** This function member creates an instance of the CRetrieveMobilePhoneDetectedNetworks 

   189 class. 

   190 

   191 @param aPhone A reference to their RMobilePhone sub-session as it is this 

   192 sub-session that the list retrieval class will operate on.

   193 @return The newly created CRetrieveMobilePhoneDetectedNetworks class. 

   194 @capability None

   195 */

   196 	{

   197 	CRetrieveMobilePhoneDetectedNetworks* r=new(ELeave) CRetrieveMobilePhoneDetectedNetworks(aPhone);

   198 	CleanupStack::PushL(r);

   199 	r->ConstructL();

   200 	CleanupStack::Pop();

   201 	return r;

   202 	}	

   203 

   204 CRetrieveMobilePhoneDetectedNetworks::CRetrieveMobilePhoneDetectedNetworks(RMobilePhone& aPhone) 

   205 :	CAsyncRetrievePhoneList(aPhone), iListExtensionId(KETelExtMultimodeV1)

   206 	{

   207 	}

   208 

   209 void CRetrieveMobilePhoneDetectedNetworks::ConstructL()

   210 	{

   211 		iIpcPhase1=EMobilePhoneGetDetectedNetworksPhase1;

   212 		iIpcPhase2=EMobilePhoneGetDetectedNetworksPhase2;

   213 		iIpcCancel=EMobilePhoneGetDetectedNetworksCancel;

   214 	}

   215 

   216 EXPORT_C CRetrieveMobilePhoneDetectedNetworks::~CRetrieveMobilePhoneDetectedNetworks()

   217 /** The destructor frees all resources owned by the object, prior to its destruction. */

   218 	{

   219 	delete iResults;

   220 	delete iResultsV2;

   221 	delete iResultsV5;

   222 	delete iResultsV8;

   223 

   224 	}

   225 

   226 EXPORT_C CMobilePhoneNetworkList* CRetrieveMobilePhoneDetectedNetworks::RetrieveListL()

   227 /** This function member provides the client with a handle to the list class retrieved 

   228 from the phone. The client will call this function member once Start() has 

   229 completed.

   230 

   231 When the client calls this function member the ownership of the CMobilePhoneNetworkList 

   232 object will transfer to the client, so the client is then responsible for 

   233 eventual deletion of this object. 

   234 

   235 @leave KErrNotFound If there is no valid list object to return to the client. 

   236 @return A handle to the list class retrieved from the store. If there are no entries in 

   237 the list then a handle to an empty list is returned.

   238 @capability None

   239 */

   240 	{

   241 	if (iResults)

   242 		{

   243 		// Give ownership of list to caller of this method

   244 		CMobilePhoneNetworkList* ptr=iResults;

   245 		iResults=NULL;

   246 		return ptr;

   247 		}

   248 	else

   249 		{

   250 		User::Leave(KErrNotFound);

   251 		return NULL;

   252 		}

   253 	}

   254 

   255 EXPORT_C CMobilePhoneNetworkListV2* CRetrieveMobilePhoneDetectedNetworks::RetrieveListV2L()

   256 /** This function member provides the client with a handle to the CMobilePhoneNetworkListV2 

   257 list class retrieved from the phone. The client will call this function member once 

   258 StartV2() has completed.

   259 

   260 When the client calls this function member the ownership of the CMobilePhoneNetworkListV2 

   261 object will transfer to the client, so the client is then responsible for 

   262 eventual deletion of this object. 

   263 

   264 @leave KErrNotFound If there is no valid list object to return to the client. 

   265 @return A handle to the list class retrieved from the store. If there are no entries in 

   266 the list then a handle to an empty list is returned.

   267 @capability None

   268 */

   269 	{

   270 	if (iResultsV2)

   271 		{

   272 		// Give ownership of list to caller of this method

   273 		CMobilePhoneNetworkListV2* ptr=iResultsV2;

   274 		iResultsV2=NULL;

   275 		return ptr;

   276 		}

   277 	else

   278 		{

   279 		User::Leave(KErrNotFound);

   280 		return NULL;

   281 		}

   282 	}

   283 

   284 EXPORT_C CMobilePhoneNetworkListV5* CRetrieveMobilePhoneDetectedNetworks::RetrieveListV5L()

   285 /** This function member provides the client with a handle to the CMobilePhoneNetworkListV5

   286 list class retrieved from the phone. The client will call this function member once 

   287 StartV5() has completed.

   288 

   289 When the client calls this function member the ownership of the CMobilePhoneNetworkListV5 

   290 object will transfer to the client, so the client is then responsible for 

   291 eventual deletion of this object. 

   292 

   293 @leave KErrNotFound If there is no valid list object to return to the client. 

   294 @return A handle to the list class retrieved from the store. If there are no entries in 

   295 the list then a handle to an empty list is returned.

   296 @capability None

   297 */

   298 	{

   299 	if (iResultsV5)

   300 		{

   301 		// Give ownership of list to caller of this method

   302 		CMobilePhoneNetworkListV5* ptr=iResultsV5;

   303 		iResultsV5=NULL;

   304 		return ptr;

   305 		}

   306 	else

   307 		{

   308 		User::Leave(KErrNotFound);

   309 		return NULL;

   310 		}

   311 	}

   312 

   313 EXPORT_C CMobilePhoneNetworkListV8* CRetrieveMobilePhoneDetectedNetworks::RetrieveListV8L()

   314 /** This function member provides the client with a handle to the CMobilePhoneNetworkListV8

   315 list class retrieved from the phone. The client will call this function member once 

   316 StartV8() has completed.

   317 

   318 When the client calls this function member the ownership of the CMobilePhoneNetworkListV8 

   319 object will transfer to the client, so the client is then responsible for 

   320 eventual deletion of this object. 

   321 

   322 @leave KErrNotFound If there is no valid list object to return to the client. 

   323 @return A handle to the list class retrieved from the store. If there are no entries in 

   324 the list then a handle to an empty list is returned.

   325 @capability None

   326 */

   327 	{

   328 	if (iResultsV8)

   329 		{

   330 		// Give ownership of list to caller of this method

   331 		CMobilePhoneNetworkListV8* ptr=iResultsV8;

   332 		iResultsV8=NULL;

   333 		return ptr;

   334 		}

   335 	else

   336 		{

   337 		User::Leave(KErrNotFound);

   338 		return NULL;

   339 		}

   340 	}

   341 

   342 EXPORT_C void CRetrieveMobilePhoneDetectedNetworks::Start(TRequestStatus& aReqStatus)

   343 /** This function member starts the two-phase list retrieval of detected networks.

   344 

   345 @param aReqStatus On completion, the status of the request; KErrNone if successful, 

   346 KErrNotSupported if the phone does not support access to a detected network 

   347 store and KErrNotFound if the store does not exist. If the list is empty then KErrNone

   348 is returned. 

   349 @capability NetworkServices

   350 @capability ReadDeviceData

   351 */

   352 	{

   353 	if (!CompleteIfInUse(aReqStatus))

   354 		{

   355 		iIpcPhase1=EMobilePhoneGetDetectedNetworksPhase1;

   356 		iIpcPhase2=EMobilePhoneGetDetectedNetworksPhase2;

   357 		iIpcCancel=EMobilePhoneGetDetectedNetworksCancel;

   358 		iListExtensionId = KETelExtMultimodeV1;

   359 

   360 		delete iResults;

   361 		iResults = NULL;

   362 		CAsyncRetrieveVariableLengthBufferV2::Start(aReqStatus,&iId,&iId);

   363 		}

   364 	}

   365 

   366 EXPORT_C void CRetrieveMobilePhoneDetectedNetworks::StartV2(TRequestStatus& aReqStatus)

   367 /** This function member starts the two-phase list retrieval of detected networks.

   368 

   369 @param aReqStatus On completion, the status of the request; KErrNone if successful, 

   370 KErrNotSupported if the phone does not support access to a detected network 

   371 store and KErrNotFound if the store does not exist. If the list is empty then KErrNone

   372 is returned. 

   373 @capability NetworkServices

   374 @capability ReadDeviceData

   375 */

   376 	{

   377 	if (!CompleteIfInUse(aReqStatus))

   378 		{

   379 		iIpcPhase1=EMobilePhoneGetDetectedNetworksV2Phase1;

   380 		iIpcPhase2=EMobilePhoneGetDetectedNetworksV2Phase2;

   381 		iIpcCancel=EMobilePhoneGetDetectedNetworksV2Cancel;

   382 		iListExtensionId = KETelExtMultimodeV2;

   383 		

   384 		delete iResultsV2;

   385 		iResultsV2 = NULL;

   386 		CAsyncRetrieveVariableLengthBufferV2::Start(aReqStatus,&iId,&iId);

   387 		}

   388 	}

   389 

   390 EXPORT_C void CRetrieveMobilePhoneDetectedNetworks::StartV5(TRequestStatus& aReqStatus)

   391 /** This function member starts the two-phase list retrieval of detected networks.

   392 

   393 @param aReqStatus On completion, the status of the request; KErrNone if successful, 

   394 KErrNotSupported if the phone does not support access to a detected network 

   395 store and KErrNotFound if the store does not exist. If the list is empty then KErrNone

   396 is returned. 

   397 @capability NetworkServices

   398 @capability ReadDeviceData

   399 */

   400 	{

   401 	if (!CompleteIfInUse(aReqStatus))

   402 		{

   403 		iIpcPhase1=EMobilePhoneGetDetectedNetworksV5Phase1;

   404 		iIpcPhase2=EMobilePhoneGetDetectedNetworksV5Phase2;

   405 		iIpcCancel=EMobilePhoneGetDetectedNetworksV5Cancel;

   406 		iListExtensionId = KEtelExtMultimodeV5;

   407 		

   408 		delete iResultsV5;

   409 		iResultsV5 = NULL;

   410 		CAsyncRetrieveVariableLengthBufferV2::Start(aReqStatus,&iId,&iId);

   411 		}

   412 	}

   413 

   414 EXPORT_C void CRetrieveMobilePhoneDetectedNetworks::StartV8(TRequestStatus& aReqStatus)

   415 /** This function member starts the two-phase list retrieval of detected networks.

   416 

   417 @param aReqStatus On completion, the status of the request; KErrNone if successful, 

   418 KErrNotSupported if the phone does not support access to a detected network 

   419 store and KErrNotFound if the store does not exist. If the list is empty then KErrNone

   420 is returned. 

   421 @capability NetworkServices

   422 @capability ReadDeviceData

   423 */

   424 	{

   425 	if (!CompleteIfInUse(aReqStatus))

   426 		{

   427 		iIpcPhase1=EMobilePhoneGetDetectedNetworksV8Phase1;

   428 		iIpcPhase2=EMobilePhoneGetDetectedNetworksV8Phase2;

   429 		iIpcCancel=EMobilePhoneGetDetectedNetworksV8Cancel;

   430 		iListExtensionId = KEtelExtMultimodeV8;

   431 		

   432 		delete iResultsV8;

   433 		iResultsV8 = NULL;

   434 		CAsyncRetrieveVariableLengthBufferV2::Start(aReqStatus,&iId,&iId);

   435 		}

   436 	}

   437 

   438 void CRetrieveMobilePhoneDetectedNetworks::RestoreListL()

   439 /**

   440  * This method restores a list from a buffer that contains the streamed version of the list

   441  */

   442 	{

   443 	if(iListExtensionId == KETelExtMultimodeV1)

   444 		{	

   445 		iResults=CMobilePhoneNetworkList::NewL();

   446 		iResults->RestoreL(iResultsPtr);

   447 		FreeBuffer();

   448 		}

   449 	else if(iListExtensionId == KETelExtMultimodeV2)

   450 		{

   451 		iResultsV2=CMobilePhoneNetworkListV2::NewL();

   452 		iResultsV2->RestoreL(iResultsPtr);

   453 		FreeBuffer();

   454 		}

   455 	else if(iListExtensionId == KEtelExtMultimodeV5)

   456 		{

   457 		iResultsV5=CMobilePhoneNetworkListV5::NewL();

   458 		iResultsV5->RestoreL(iResultsPtr);

   459 		FreeBuffer();

   460 		}

   461 	else if(iListExtensionId == KEtelExtMultimodeV8)

   462 		{

   463 		iResultsV8=CMobilePhoneNetworkListV8::NewL();

   464 		iResultsV8->RestoreL(iResultsPtr);

   465 		FreeBuffer();

   466 		}

   467 	else

   468 		{

   469 		User::Leave(KErrNotFound);

   470 		}

   471 

   472 	}

   473 

   474 

   475 /***********************************************************************************/

   476 //

   477 // Retrieve a list of call forwarding status/info

   478 //

   479 /***********************************************************************************/

   480 

   481 EXPORT_C CRetrieveMobilePhoneCFList* CRetrieveMobilePhoneCFList::NewL(RMobilePhone& aPhone)

   482 /** This member function creates an instance of the CRetrieveMobilePhoneCFList 

   483 class.

   484 

   485 @param aPhone A reference to the RMobilePhone sub-session as it is this sub-session 

   486 that the list retrieval class will operate on.

   487 @return A pointer to the newly created CRetrieveMobilePhoneCFList object. 

   488 */

   489 	{

   490 	CRetrieveMobilePhoneCFList* r=new(ELeave) CRetrieveMobilePhoneCFList(aPhone);

   491 	CleanupStack::PushL(r);

   492 	r->ConstructL();

   493 	CleanupStack::Pop();

   494 	return r;

   495 	}	

   496 

   497 CRetrieveMobilePhoneCFList::CRetrieveMobilePhoneCFList(RMobilePhone& aPhone) : 

   498 	CAsyncRetrievePhoneList(aPhone)

   499 	{

   500 	}

   501 

   502 void CRetrieveMobilePhoneCFList::ConstructL()

   503 	{

   504 	iIpcPhase1=EMobilePhoneGetCallForwardingStatusPhase1;

   505 	iIpcPhase2=EMobilePhoneGetCallForwardingStatusPhase2;

   506 	iIpcCancel=EMobilePhoneGetCallForwardingStatusCancel;	

   507 	}

   508 

   509 EXPORT_C CRetrieveMobilePhoneCFList::~CRetrieveMobilePhoneCFList()

   510 /** The destructor frees all resources owned by the object, prior to its destruction. */

   511 	{

   512 	delete iResults;

   513 	}

   514 

   515 EXPORT_C CMobilePhoneCFList* CRetrieveMobilePhoneCFList::RetrieveListL()

   516 /** This member function provides the client with a handle to the list class retrieved 

   517 from the phone. The client will call this member function once Start() has 

   518 completed. The retrieved list will consist of an entry per basic service group 

   519 per specified CF condition. When the client calls this member function the 

   520 ownership of the CMobilePhoneCFList object will transfer to the client, so 

   521 the client is then responsible for eventual deletion of this object.

   522 

   523 @leave KErrNotFound If there is no valid list object to return to the client. 

   524 @return A handle to the list class retrieved from the store. If there are no entries in 

   525 the list then a handle to an empty list is returned.

   526 */

   527 	{

   528 	if (iResults)

   529 		{

   530 		// Give ownership of list to caller of this method

   531 		CMobilePhoneCFList* ptr=iResults;

   532 		iResults=NULL;

   533 		return ptr;

   534 		}

   535 	else

   536 		{

   537 		User::Leave(KErrNotFound);

   538 		return NULL;

   539 		}

   540 	}

   541 

   542 EXPORT_C void CRetrieveMobilePhoneCFList::Start(TRequestStatus& aReqStatus, 

   543 												RMobilePhone::TMobilePhoneCFCondition aCondition, 

   544 												RMobilePhone::TMobileInfoLocation aLocation)

   545 /**

   546  * This method starts the retrieval of the call forwarding status list

   547  *

   548  * @deprecated 7.0s.

   549  * Deprecated, other CRetrieveMobilePhoneCFList::Start overload should be used instead

   550  * @capability NetworkServices 

   551  * @capability ReadDeviceData

   552  */

   553 	{

   554 	if (!CompleteIfInUse(aReqStatus))

   555 		{

   556 		delete iResults;

   557 		iResults = NULL;

   558 

   559 		iCFRequestData().iCondition=aCondition;

   560 		iCFRequestData().iLocation=aLocation;

   561 		iCFRequestData().iClient=iId();

   562 		iCFRequestData().iServiceGroup=RMobilePhone::EAllServices;

   563 

   564 		CAsyncRetrievePhoneList::Start(aReqStatus,&iCFRequestData,&iId);

   565 		}

   566 	}

   567 	

   568 EXPORT_C void CRetrieveMobilePhoneCFList::Start(TRequestStatus& aReqStatus, 

   569 												RMobilePhone::TMobilePhoneCFCondition aCondition, 

   570 												RMobilePhone::TMobileService aServiceGroup,

   571 												RMobilePhone::TMobileInfoLocation aLocation

   572 												)

   573 /**

   574  * This method starts the retrieval of the call forwarding status list. 

   575  * If the list is empty then KErrNone is returned. 

   576  * @capability NetworkServices 

   577  * @capability ReadDeviceData

   578  */

   579 	{

   580 	if (!CompleteIfInUse(aReqStatus))

   581 		{

   582 		

   583 		delete iResults;

   584 		iResults = NULL;

   585 

   586 		iCFRequestData().iCondition=aCondition;

   587 		iCFRequestData().iLocation=aLocation;

   588 		iCFRequestData().iClient=iId();

   589 		iCFRequestData().iServiceGroup=aServiceGroup;

   590 

   591 		CAsyncRetrievePhoneList::Start(aReqStatus,&iCFRequestData,&iId);

   592 		}

   593 	}

   594 		

   595 void CRetrieveMobilePhoneCFList::RestoreListL()

   596 /**

   597  * This method restores a list from a buffer that contains the streamed version of the list

   598  */

   599 	{

   600 	iResults=CMobilePhoneCFList::NewL();

   601 	iResults->RestoreL(iResultsPtr);

   602 	FreeBuffer();

   603 	}

   604 

   605 /***********************************************************************************/

   606 //

   607 // Retrieve a list of call barring status/info

   608 //

   609 /***********************************************************************************/

   610 

   611 EXPORT_C CRetrieveMobilePhoneCBList* CRetrieveMobilePhoneCBList::NewL(RMobilePhone& aPhone)

   612 /** This member function creates an instance of the CRetrieveMobilePhoneCBList 

   613 class.

   614 

   615 @param aPhone A reference to the RMobilePhone sub-session, as it is this sub-session 

   616 that the list retrieval class will operate on.

   617 @return A pointer to the newly created CRetrieveMobilePhoneCBList object. 

   618 @capability None

   619 */

   620 	{

   621 	CRetrieveMobilePhoneCBList* r=new(ELeave) CRetrieveMobilePhoneCBList(aPhone);

   622 	CleanupStack::PushL(r);

   623 	r->ConstructL();

   624 	CleanupStack::Pop();

   625 	return r;

   626 	}	

   627 

   628 CRetrieveMobilePhoneCBList::CRetrieveMobilePhoneCBList(RMobilePhone& aPhone) : 

   629 	CAsyncRetrievePhoneList(aPhone), iListExtensionId(KETelExtMultimodeV1)

   630 	{

   631 	}

   632 

   633 void CRetrieveMobilePhoneCBList::ConstructL()

   634 	{

   635 	}

   636 

   637 EXPORT_C CRetrieveMobilePhoneCBList::~CRetrieveMobilePhoneCBList()

   638 /** The destructor frees all resources owned by the object, prior to its destruction. */

   639 	{

   640 	delete iResults;

   641 	}

   642 

   643 EXPORT_C CMobilePhoneCBList* CRetrieveMobilePhoneCBList::RetrieveListL()

   644 /** This member function provides the client with a handle to the list class retrieved 

   645 from the phone.

   646 

   647 The client will call this member function once Start() has completed. The 

   648 retrieved list will consist of an entry per basic service group per specified 

   649 CB condition.

   650 

   651 When the client calls this member function the ownership of the CMobilePhoneCBList 

   652 object will transfer to the client, so the client is then responsible for 

   653 eventual deletion of this object.

   654 

   655 @leave KErrNotFound If there is no valid list object to return to the client.

   656 @return A handle to the list class retrieved from the store. If there are no entries in 

   657 the list then a handle to an empty list is returned.

   658 @capability ReadDeviceData

   659 */

   660 	{

   661 	if (iResults)

   662 		{

   663 		// Give ownership of list to caller of this method

   664 		CMobilePhoneCBList* ptr=iResults;

   665 		iResults=NULL;

   666 		return ptr;

   667 		}

   668 	else

   669 		{

   670 		User::Leave(KErrNotFound);

   671 		return NULL;

   672 		}

   673 	}

   674 

   675 

   676 

   677 EXPORT_C void CRetrieveMobilePhoneCBList::Start(TRequestStatus& aReqStatus, 

   678 												RMobilePhone::TMobilePhoneCBCondition aCondition, 

   679 												RMobilePhone::TMobileInfoLocation aLocation)

   680 /** This member function starts the two-phase list retrieval. The client also specifies 

   681 the call barring condition(s) that it wants to interrogate and from where 

   682 this information should be retrieved. The client then waits for its request 

   683 to be completed.

   684 

   685 @param aReqStatus On completion, the status of the request; KErrNone if successful, 

   686 KErrNotSupported if the phone does not support access to a CB list store and 

   687 KErrNotFound if the store does not exist. If the list is empty then KErrNone

   688 is returned.

   689 @param aCondition The barring conditions to interrogate.

   690 @param aLocation Specifies from where this information should be retrieved. 

   691 This parameters defaults to: RMobilePhone::EInfoLocationCachePreferred.

   692 @capability NetworkServices

   693 @capability ReadDeviceData

   694 */

   695 	{

   696 	if (!CompleteIfInUse(aReqStatus))

   697 		{

   698 		

   699 		iIpcPhase1 = EMobilePhoneGetBarringStatusPhase1;

   700 		iIpcPhase2 = EMobilePhoneGetBarringStatusPhase2;

   701 		iIpcCancel = EMobilePhoneGetBarringStatusCancel;

   702 		iListExtensionId = KETelExtMultimodeV1;

   703 		

   704 		delete iResults;

   705 		iResults = NULL;

   706 

   707 		iCBRequestData().iCondition=aCondition;

   708 		iCBRequestData().iLocation=aLocation;

   709 		iCBRequestData().iClient=iId();

   710 		

   711 		CAsyncRetrievePhoneList::Start(aReqStatus,&iCBRequestData,&iId);

   712 		}

   713 	}

   714 		

   715 		

   716 void CRetrieveMobilePhoneCBList::RestoreListL()

   717 /**

   718  * This method restores a list from a buffer that contains the streamed version of the list

   719  */

   720 	{

   721 	if(iListExtensionId == KETelExtMultimodeV1)

   722 		{

   723 	iResults=CMobilePhoneCBList::NewL();

   724 	iResults->RestoreL(iResultsPtr);

   725 	FreeBuffer();

   726 	}

   727 	else

   728 		User::Leave(KErrNotFound);

   729 	}

   730 

   731 /***********************************************************************************/

   732 //

   733 // Retrieve a list of call waiting status/info

   734 //

   735 /***********************************************************************************/

   736 

   737 EXPORT_C CRetrieveMobilePhoneCWList* CRetrieveMobilePhoneCWList::NewL(RMobilePhone& aPhone)

   738 /** This function member creates an instance of the CRetrieveMobilePhoneCWList 

   739 class.

   740 

   741 @param aPhone A reference to the RMobilePhone sub-session as this is the sub-session 

   742 that the list retrieval class will operate on.

   743 @return A pointer to the newly created CRetrieveMobilePhoneCWList object. 

   744 @capability None

   745 */

   746 	{

   747 	CRetrieveMobilePhoneCWList* r=new(ELeave) CRetrieveMobilePhoneCWList(aPhone);

   748 	CleanupStack::PushL(r);

   749 	r->ConstructL();

   750 	CleanupStack::Pop();

   751 	return r;

   752 	}	

   753 

   754 CRetrieveMobilePhoneCWList::CRetrieveMobilePhoneCWList(RMobilePhone& aPhone) : 

   755 	CAsyncRetrievePhoneList(aPhone)

   756 	{

   757 	}

   758 

   759 void CRetrieveMobilePhoneCWList::ConstructL()

   760 	{

   761 	iIpcPhase1=EMobilePhoneGetWaitingStatusPhase1;

   762 	iIpcPhase2=EMobilePhoneGetWaitingStatusPhase2;

   763 	iIpcCancel=EMobilePhoneGetWaitingStatusCancel;

   764 	}

   765 

   766 EXPORT_C CRetrieveMobilePhoneCWList::~CRetrieveMobilePhoneCWList()

   767 /** The destructor frees all resources owned by the object, prior to its destruction. */

   768 	{

   769 	delete iResults;

   770 	}

   771 

   772 EXPORT_C CMobilePhoneCWList* CRetrieveMobilePhoneCWList::RetrieveListL()

   773 /** This function member provides the client with a handle to the list class retrieved 

   774 from the phone. The client will call this function member once Start() has 

   775 completed.

   776 

   777 When the client calls this function member the ownership of the CMobilePhoneCWList 

   778 object will transfer to the client, so the client is then responsible for 

   779 eventual deletion of this object.

   780 

   781 @leave KErrNotFound If there is no valid list object to return to the client

   782 @return A handle to the list class retrieved from the store. If there are no entries in 

   783 the list then a handle to an empty list is returned.

   784 @capability ReadDeviceData

   785 */

   786 	{

   787 	if (iResults)

   788 		{

   789 		// Give ownership of list to caller of this method

   790 		CMobilePhoneCWList* ptr=iResults;

   791 		iResults=NULL;

   792 		return ptr;

   793 		}

   794 	else

   795 		{

   796 		User::Leave(KErrNotFound);

   797 		return NULL;

   798 		}

   799 	}

   800 

   801 EXPORT_C void CRetrieveMobilePhoneCWList::Start(TRequestStatus& aReqStatus, 

   802 												RMobilePhone::TMobileInfoLocation aLocation)

   803 /** This function member starts the two-phase list retrieval.

   804 

   805 @param aReqStatus On completion, the status of the request; KErrNone if successful, 

   806 KErrNotSupported if the phone does not support access to a call waiting list 

   807 store and KErrNotFound if the store does not exist. If the list is empty then KErrNone

   808 is returned.

   809 @param aLocation Specifies from where this information should be retrieved. 

   810 Defaults to RMobilePhone::EInfoLocationCachePreferred

   811 @capability NetworkServices

   812 @capability ReadDeviceData

   813 */

   814 	{

   815 	if (!CompleteIfInUse(aReqStatus))

   816 		{

   817 		delete iResults;

   818 		iResults = NULL;

   819 

   820 		iCWRequestData().iLocation=aLocation;

   821 		iCWRequestData().iClient=iId();

   822 			

   823 		CAsyncRetrievePhoneList::Start(aReqStatus,&iCWRequestData,&iId);

   824 		}

   825 	}

   826 		

   827 void CRetrieveMobilePhoneCWList::RestoreListL()

   828 /**

   829  * This method restores a list from a buffer that contains the streamed version of the list

   830  */

   831 	{

   832 	iResults=CMobilePhoneCWList::NewL();

   833 	iResults->RestoreL(iResultsPtr);

   834 	FreeBuffer();

   835 	}

   836 

   837 

   838 /***********************************************************************************/

   839 //

   840 // Retrieve a list of call completion Requests

   841 //

   842 /***********************************************************************************/

   843 

   844 EXPORT_C CRetrieveMobilePhoneCcbsList* CRetrieveMobilePhoneCcbsList::NewL(RMobilePhone& aPhone)

   845 /** This member function creates an instance of the CRetrieveMobilePhoneCcbsList 

   846 class.

   847 

   848 @param aPhone A reference to the RMobilePhone sub-session, as it is this sub-session 

   849 that the list retrieval class will operate on.

   850 @return A pointer to the newly created CRetrieveMobilePhoneCcbsList object. 

   851 @capability None

   852 */

   853 	{

   854 	CRetrieveMobilePhoneCcbsList* r=new(ELeave) CRetrieveMobilePhoneCcbsList(aPhone);

   855 	CleanupStack::PushL(r);

   856 	r->ConstructL();

   857 	CleanupStack::Pop();

   858 	return r;

   859 	}	

   860 

   861 CRetrieveMobilePhoneCcbsList::CRetrieveMobilePhoneCcbsList(RMobilePhone& aPhone) : 

   862 	CAsyncRetrievePhoneList(aPhone)

   863 	{

   864 	}

   865 

   866 void CRetrieveMobilePhoneCcbsList::ConstructL()

   867 	{

   868 	iIpcPhase1=EMobilePhoneGetCompletionRequestsPhase1;

   869 	iIpcPhase2=EMobilePhoneGetCompletionRequestsPhase2;

   870 	iIpcCancel=EMobilePhoneGetCompletionRequestsCancel;	

   871 	}

   872 

   873 EXPORT_C CRetrieveMobilePhoneCcbsList::~CRetrieveMobilePhoneCcbsList()

   874 /** The destructor frees all resources owned by the object, prior to its destruction. */

   875 	{

   876 	delete iResults;

   877 	}

   878 

   879 EXPORT_C CMobilePhoneCcbsList* CRetrieveMobilePhoneCcbsList::RetrieveListL()

   880 /** This member function provides the client with a handle to the list class retrieved 

   881 from the phone. The client will call this member function once Start() has 

   882 completed.

   883 

   884 When the client calls this member function the ownership of the CMobilePhoneCcbsList 

   885 object will transfer to the client, so the client is then responsible for 

   886 eventual deletion of this object.

   887 

   888 @leave KErrNotFound If there is no valid list object to return to the client.

   889 @return A handle to the list class retrieved from the store. If there are no entries in 

   890 the list then a handle to an empty list is returned.

   891 @capability ReadDeviceData

   892 */

   893 	{

   894 	if (iResults)

   895 		{

   896 		// Give ownership of list to caller of this method

   897 		CMobilePhoneCcbsList* ptr=iResults;

   898 		iResults=NULL;

   899 		return ptr;

   900 		}

   901 	else

   902 		{

   903 		User::Leave(KErrNotFound);

   904 		return NULL;

   905 		}

   906 	}

   907 

   908 EXPORT_C void CRetrieveMobilePhoneCcbsList::Start(TRequestStatus& aReqStatus)

   909 /** This member function starts the two-phase list retrieval.

   910 

   911 @param aReqStatus On completion, the status of the request; KErrNone if successful, 

   912 KErrNotSupported if the phone does not support access to a CCBS list store 

   913 and KErrNotFound if the store does not exist. If the list is empty then KErrNone

   914 is returned. 

   915 @capability NetworkServices

   916 @capability ReadDeviceData

   917 */

   918 	{

   919 	if (!CompleteIfInUse(aReqStatus))

   920 		{

   921 		delete iResults;

   922 		iResults = NULL;

   923 

   924 		CAsyncRetrievePhoneList::Start(aReqStatus,&iId,&iId);

   925 		}

   926 	}

   927 		

   928 void CRetrieveMobilePhoneCcbsList::RestoreListL()

   929 /**

   930  * This method restores a list from a buffer that contains the streamed version of the list

   931  */

   932 	{

   933 	iResults=CMobilePhoneCcbsList::NewL();

   934 	iResults->RestoreL(iResultsPtr);

   935 	FreeBuffer();

   936 	}

   937 

   938 /***********************************************************************************/

   939 //

   940 // Retrieve a list of SMS messages from a phone-side SMS store

   941 //

   942 /***********************************************************************************/

   943 

   944 EXPORT_C CRetrieveMobilePhoneSmsList* CRetrieveMobilePhoneSmsList::NewL(RMobilePhoneStore& aStore, RMobileSmsStore::TMobileSmsEntryExtensionId aType)

   945 /** This function member creates an instance of the CActive derived CRetrieveMobilePhoneSmsList 

   946 class.

   947 

   948 @param aStore An instance of RMobileSmsStore as this store that the list retrieval 

   949 class will operate on.

   950 @param aType Specifies whether GSM or CDMA message store entries will be retrieved.

   951 @return The newly created CRetrieveMobilePhoneSmsList class. 

   952 @capability None

   953 */

   954 	{

   955 	CRetrieveMobilePhoneSmsList* r=new(ELeave) CRetrieveMobilePhoneSmsList(aStore, aType);

   956 	CleanupStack::PushL(r);

   957 	r->ConstructL();

   958 	CleanupStack::Pop();

   959 	return r;

   960 	}	

   961 

   962 CRetrieveMobilePhoneSmsList::CRetrieveMobilePhoneSmsList(RMobilePhoneStore& aStore, RMobileSmsStore::TMobileSmsEntryExtensionId aType) 

   963 :	CAsyncRetrieveStoreList(aStore), iEntryType(aType)

   964 	{

   965 	}

   966 

   967 void CRetrieveMobilePhoneSmsList::ConstructL()

   968 	{

   969 	}

   970 

   971 EXPORT_C CRetrieveMobilePhoneSmsList::~CRetrieveMobilePhoneSmsList()

   972 /** The destructor frees all resources owned by the object, prior to its destruction. */

   973 	{

   974 	delete iGsmResults;

   975 	delete iCdmaResults;

   976 	}

   977 

   978 EXPORT_C CMobilePhoneGsmSmsList* CRetrieveMobilePhoneSmsList::RetrieveGsmListL()

   979 /** These function members will provide the client with a handle to the appropriate 

   980 GSM list class retrieved from the store.

   981 

   982 The client will call this function member once Start() has completed.

   983 

   984 When the client calls this function member the ownership of the list object 

   985 will transfer to the client, so the client is then responsible for eventual 

   986 deletion of this object. 

   987 

   988 @leave KErrNotFound If there is no valid list object to return to the client.

   989 @return A handle to the list class retrieved from the store. If there are no entries in 

   990 the list then a handle to an empty list is returned.

   991 @capability ReadUserData

   992 */

   993 	{

   994 	if ((iEntryType==RMobileSmsStore::KETelMobileGsmSmsEntryV1) && iGsmResults)

   995 		{

   996 		// Give ownership of GSM SMS list to caller of this method

   997 		CMobilePhoneGsmSmsList* ptr=iGsmResults;

   998 		iGsmResults=NULL;

   999 		return ptr;

  1000 		}

  1001 	else

  1002 		{

  1003 		User::Leave(KErrNotFound);

  1004 		return NULL;

  1005 		}

  1006 	}

  1007 	

  1008 EXPORT_C CMobilePhoneCdmaSmsList* CRetrieveMobilePhoneSmsList::RetrieveCdmaListL()

  1009 /** These function members will provide the client with a handle to the appropriate 

  1010 CDMA list class retrieved from the store.

  1011 

  1012 The client will call this function member once Start() has completed.

  1013 

  1014 When the client calls this function member the ownership of the list object 

  1015 will transfer to the client, so the client is then responsible for eventual 

  1016 deletion of this object. 

  1017 

  1018 @leave KErrNotFound If there is no valid list object to return to the client. 

  1019 @return A handle to the list class retrieved from the store. If there are no entries in 

  1020 the list then a handle to an empty list is returned.

  1021 @capability ReadUserData

  1022 */

  1023 	{

  1024 	if ((iEntryType==RMobileSmsStore::KETelMobileCdmaSmsEntryV1) && iCdmaResults)

  1025 		{

  1026 		// Give ownership of CDMA SMS list to caller of this method

  1027 		CMobilePhoneCdmaSmsList* ptr=iCdmaResults;

  1028 		iCdmaResults=NULL;

  1029 		return ptr;

  1030 		}

  1031 	else

  1032 		{

  1033 		User::Leave(KErrNotFound);

  1034 		return NULL;

  1035 		}

  1036 	}

  1037 	

  1038 EXPORT_C void CRetrieveMobilePhoneSmsList::Start(TRequestStatus& aReqStatus)

  1039 /** This function member starts the two-phase list retrieval of all entries within 

  1040 the store.

  1041 

  1042 @param aReqStatus On completion, the status of the request; KErrNone if successful, 

  1043 KErrNotSupported if the phone does not support access to an SMS list store 

  1044 and KErrNotFound if the store does not exist. If the list is empty then KErrNone

  1045 is returned.

  1046 @capability ReadUserData

  1047 */

  1048 	{

  1049 	InitiateRequest(aReqStatus,EFalse,KValueNotUsed,KValueNotUsed);

  1050 	}

  1051 	

  1052 EXPORT_C void CRetrieveMobilePhoneSmsList::StartBatch(TRequestStatus& aReqStatus, TInt aStartIndex, TInt aBatchSize)

  1053 /** This function member starts the two-phase list retrieval of a batch of entries.

  1054 

  1055 The client must supply the index (i.e. slot location) from which to start 

  1056 the batch retrieval and the number of entries to retrieve in that batch. Please 

  1057 note, that if the client specifies aStartIndex=X and aBatchSize=Y, the TSY 

  1058 should look in slot X to start with and then continue looking in slots until 

  1059 Y used entries are found (or less if the end of the store is reached). When 

  1060 the client receives the batch, the slot index attribute of the last entry 

  1061 in the list is not necessarily equal to aStartIndex+aBatchSize due to the 

  1062 possibility of empty slots. 

  1063 

  1064 @param aReqStatus On return, the status of the request; KErrNone if successful, 

  1065 KErrNotSupported if the phone does not support access to an emergency number 

  1066 store and KErrNotFound if the store does not exist. If the list is empty then KErrNone

  1067 is returned.

  1068 @param aStartIndex The slot where the TSY will start looking.

  1069 @param aBatchSize The number of entries the TSY will try to get. 

  1070 @capability ReadUserData

  1071 */

  1072 	{

  1073 	InitiateRequest(aReqStatus,ETrue,aStartIndex,aBatchSize);

  1074 	}

  1075 

  1076 void CRetrieveMobilePhoneSmsList::InitiateRequest(TRequestStatus& aReqStatus, TBool aBatch, TInt aStartIndex, TInt aBatchSize)

  1077 /**

  1078  * This method uses the base class's generic Start() method to start either reading 

  1079  * the whole list or just a batch of entries

  1080  *

  1081  * @param aReqStatus returns the result code after the asynchronous call completes

  1082  * @param aBatch Specifies whether a batch or all entries is being read

  1083  * @param aStartIndex Specifies the first index of the batch

  1084  * @param aBatchSize Specifies how many entries to read after the start

  1085  */

  1086 	{

  1087 	if (!CompleteIfInUse(aReqStatus))

  1088 		{

  1089 		delete iGsmResults;

  1090 		iGsmResults = NULL;

  1091 		delete iCdmaResults;

  1092 		iCdmaResults = NULL;

  1093 

  1094 		iRequestData().iClient=iId();

  1095 		iRequestData().iEntryType = iEntryType;

  1096 		iRequestData().iBatchRequest = aBatch;

  1097 		iRequestData().iStartIndex = aStartIndex;

  1098 		iRequestData().iBatchSize = aBatchSize;

  1099 		CAsyncRetrieveVariableLengthBufferV2::Start(aReqStatus,&iRequestData,&iId);

  1100 		}

  1101 	}

  1102 

  1103 void CRetrieveMobilePhoneSmsList::RestoreListL()

  1104 /**

  1105  * This method restores a list from a buffer that contains the streamed version of the list

  1106  */

  1107 	{

  1108 	if (iEntryType==RMobileSmsStore::KETelMobileGsmSmsEntryV1)

  1109 		{

  1110 		iGsmResults=CMobilePhoneGsmSmsList::NewL();

  1111 		iGsmResults->RestoreL(iResultsPtr);

  1112 		}

  1113 	else

  1114 		{

  1115 		iCdmaResults=CMobilePhoneCdmaSmsList::NewL();

  1116 		iCdmaResults->RestoreL(iResultsPtr);

  1117 		}

  1118 	FreeBuffer();

  1119 	}

  1120 

  1121 /***********************************************************************************/

  1122 //

  1123 // Retrieve a list of SMS parameters from a phone-side SMSP store

  1124 //

  1125 /***********************************************************************************/

  1126 

  1127 EXPORT_C CRetrieveMobilePhoneSmspList* CRetrieveMobilePhoneSmspList::NewL(RMobileSmsMessaging& aMessaging)

  1128 /** This member function creates an instance of the CActive derived CRetrieveMobilePhoneCbmiList 

  1129 class.

  1130 

  1131 @param aMessaging An instance of RMobileSmsMessaging as it is this messaging 

  1132 sub-session that the list retrieval class will operate on.

  1133 @return The newly created CRetrieveMobilePhoneSmspList class. 

  1134 @capability None

  1135 */