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 // Multimode ETel API v1.0

    15 // Header file for asynchronous list retrieval classes

    16 // 

    17 //

    18 

    19 /**

    20  @file

    21  @publishedPartner

    22 */

    23 

    24 #ifndef _MMRETRIEVE_H_

    25 #define _MMRETRIEVE_H_

    26 

    27 #include <etelmm.h>

    28 #include <mmlist.h>

    29 

    30 #include <e32base.h>

    31 #include <etelutils.h>

    32 

    33 /**

    34 This class is not intended for public use.  It is a stub class to maintain a consistent def file.  

    35 CAsyncRetrieveVariableLengthBufferV2 declared in Etel should be used instead.

    36 

    37 @see CAsyncRetrieveVariableLengthBufferV2

    38 @publishedPartner

    39 @released

    40 */

    41 class CAsyncRetrieveVariableLengthBuffer : public CActive

    42 	{

    43 protected:

    44 	IMPORT_C void Start(TRequestStatus& aReqStatus, TDes8* aPhase1Request, TDes8* aPhase2Request);

    45 	IMPORT_C TBool CompleteIfInUse(TRequestStatus& aReqStatus);

    46 	IMPORT_C void FreeBuffer();

    47 private:

    48 	IMPORT_C virtual void DoCancel();

    49 	IMPORT_C virtual void RunL();

    50 protected:

    51 	CAsyncRetrieveVariableLengthBuffer();

    52 	};

    53 

    54 

    55 class CAsyncRetrieveWithClientIds : public CAsyncRetrieveVariableLengthBufferV2

    56 /**

    57 Base class that adds passing of client ID within each phase of the retrieval.

    58 

    59 This class is not intended for public use.

    60 

    61 @publishedPartner

    62 @released

    63 */

    64 	{

    65 protected:

    66 	CAsyncRetrieveWithClientIds(TInt aSessionHandle, TInt aSubSessionHandle);

    67 protected:

    68 	TPckgBuf<RMobilePhone::TClientId> iId;

    69 	};

    70 

    71 

    72 class CAsyncRetrieveStoreList : public CAsyncRetrieveWithClientIds

    73 /**

    74 Class that specialises in retrieving lists from phone store classes.

    75 

    76 @publishedPartner

    77 @released

    78 */

    79 	{

    80 public:

    81 	CAsyncRetrieveStoreList(RMobilePhoneStore& aStore);

    82 	~CAsyncRetrieveStoreList();

    83 	virtual void Get(TInt aIpc, TRequestStatus& aReqStatus, TDes8& aDes1, TDes8& aDes2);

    84 	virtual void CancelReq(TInt aIpc1, TInt aIpc2);

    85 

    86 	/** Starts the 2 phase retrieval.

    87 

    88 	@param aReqStatus On return, KErrNone if successful. */

    89 	IMPORT_C void Start(TRequestStatus& aReqStatus);

    90 

    91 protected:

    92 	RMobilePhoneStore& iStore;

    93 	};

    94 

    95 

    96 

    97 class CAsyncRetrievePhoneList : public CAsyncRetrieveWithClientIds

    98 /**

    99 Class that specialises in retrieving lists from a phone or network

   100 

   101 @publishedPartner

   102 @released

   103 */

   104 	{

   105 public:

   106 	IMPORT_C CAsyncRetrievePhoneList(RMobilePhone& aPhone);

   107 	IMPORT_C ~CAsyncRetrievePhoneList();

   108 	IMPORT_C virtual void Get(TInt aIpc, TRequestStatus& aReqStatus, TDes8& aDes1, TDes8& aDes2);

   109 	IMPORT_C virtual void CancelReq(TInt aIpc1, TInt aIpc2);

   110 

   111 protected:

   112 	RMobilePhone& iPhone;

   113 	};

   114 

   115 

   116 

   117 class CRetrieveMobilePhoneDetectedNetworks : public CAsyncRetrievePhoneList

   118 /**

   119 Retrieves a list of all networks that are currently detected by 

   120 the phone. 

   121 

   122 Each detected network will be represented by an entry in the list 

   123 class CMobilePhoneNetworkList, CMobilePhoneNetworkListV2 or 

   124 CMobilePhoneNetworkListV5 or CMobilePhoneNetworkListV8 depending on which API method is used. 

   125 

   126 Due to the probable time taken to retrieve a list, clients must use an asynchronous 

   127 approach based around the use of this object.

   128 

   129 @publishedPartner

   130 @released

   131 */

   132 	{

   133 public:

   134 	IMPORT_C static CRetrieveMobilePhoneDetectedNetworks* NewL(RMobilePhone& aPhone);

   135 	IMPORT_C ~CRetrieveMobilePhoneDetectedNetworks();

   136 

   137 	IMPORT_C void Start(TRequestStatus& aReqStatus);

   138 	IMPORT_C void StartV2(TRequestStatus& aReqStatus);

   139 	IMPORT_C void StartV5(TRequestStatus& aReqStatus);

   140 	IMPORT_C void StartV8(TRequestStatus& aReqStatus);

   141 

   142 	IMPORT_C CMobilePhoneNetworkList* RetrieveListL();

   143 	IMPORT_C CMobilePhoneNetworkListV2* RetrieveListV2L();

   144 	IMPORT_C CMobilePhoneNetworkListV5* RetrieveListV5L();

   145 	IMPORT_C CMobilePhoneNetworkListV8* RetrieveListV8L();

   146 

   147 protected:

   148 	CRetrieveMobilePhoneDetectedNetworks(RMobilePhone& aPhone);

   149 	void ConstructL();

   150 

   151 	virtual void RestoreListL();

   152 

   153 private:

   154 	CMobilePhoneNetworkList* iResults;

   155 	CMobilePhoneNetworkListV2* iResultsV2;

   156 	CMobilePhoneNetworkListV5* iResultsV5;

   157 	CMobilePhoneNetworkListV8* iResultsV8;

   158 	TInt iListExtensionId;

   159 	};

   160 

   161 

   162 

   163 class CRetrieveMobilePhoneCFList : public CAsyncRetrievePhoneList

   164 /** Retrieves the Call Forwarding status list from the phone.

   165 

   166 Due to the probable time taken to retrieve a list, clients must use an asynchronous 

   167 approach based around the use of this object.

   168 

   169 @publishedPartner

   170 @released 

   171 */

   172 	{

   173 public:

   174 

   175 	// for use by client-side API code and TSY only

   176 

   177 	struct TGetCallForwardingRequest

   178 		{

   179 		RMobilePhone::TClientId iClient;

   180 		RMobilePhone::TMobilePhoneCFCondition iCondition;

   181 		RMobilePhone::TMobileInfoLocation iLocation;

   182 		RMobilePhone::TMobileService iServiceGroup;

   183 		};

   184 

   185 public:

   186 	IMPORT_C static CRetrieveMobilePhoneCFList* NewL(RMobilePhone& aPhone);

   187 	IMPORT_C ~CRetrieveMobilePhoneCFList();

   188 

   189 	IMPORT_C void Start(TRequestStatus& aReqStatus, 

   190 						RMobilePhone::TMobilePhoneCFCondition aCondition, 

   191 						RMobilePhone::TMobileInfoLocation aLocation = RMobilePhone::EInfoLocationCachePreferred); /** @deprecated 7.0s.  Deprecated use other overload*/

   192 	

   193 	IMPORT_C void Start(TRequestStatus& aReqStatus, 

   194 						RMobilePhone::TMobilePhoneCFCondition aCondition, 

   195 						RMobilePhone::TMobileService aServiceGroup,

   196 						RMobilePhone::TMobileInfoLocation aLocation = RMobilePhone::EInfoLocationCachePreferred

   197 						);

   198 

   199 	IMPORT_C CMobilePhoneCFList* RetrieveListL();

   200 

   201 protected:

   202 	CRetrieveMobilePhoneCFList(RMobilePhone& aPhone);

   203 	void ConstructL();

   204 

   205 	virtual void RestoreListL();

   206 

   207 private:

   208 	CMobilePhoneCFList* iResults;

   209 	TPckgBuf<TGetCallForwardingRequest> iCFRequestData;

   210 	};

   211 

   212 

   213 

   214 

   215 class CRetrieveMobilePhoneCBList : public CAsyncRetrievePhoneList

   216 /** Retrieves the Call Barring status list from the phone.

   217 

   218 The following are all described as applicable to both GSM and CDMA because

   219 although it is not possible to interrogate CDMA networks for call barring 

   220 service status there is nothing inherently "GSM" about these types. So if 

   221 the phone has attempted to internally support Call Barring in CDMA mode then 

   222 these types are applicable.

   223 

   224 Due to the probable time taken to retrieve a list, clients must use an asynchronous 

   225 approach based around the use this object. 

   226 @publishedPartner

   227 @released

   228 */

   229 	{

   230 public:

   231 

   232 	// for use by client-side API code and TSY only

   233 

   234 	struct TGetCallBarringRequest

   235 		{

   236 		RMobilePhone::TClientId iClient;

   237 		RMobilePhone::TMobilePhoneCBCondition iCondition;

   238 		RMobilePhone::TMobileInfoLocation iLocation;

   239 		};

   240 

   241 

   242 public:

   243 	IMPORT_C static CRetrieveMobilePhoneCBList* NewL(RMobilePhone& aPhone);

   244 	IMPORT_C ~CRetrieveMobilePhoneCBList();

   245 

   246 	IMPORT_C void Start(TRequestStatus& aReqStatus, 

   247 						RMobilePhone::TMobilePhoneCBCondition aCondition, 

   248 						RMobilePhone::TMobileInfoLocation aLocation = RMobilePhone::EInfoLocationCachePreferred);

   249 						

   250 	IMPORT_C CMobilePhoneCBList* RetrieveListL();

   251 

   252 protected:

   253 	CRetrieveMobilePhoneCBList(RMobilePhone& aPhone);

   254 	void ConstructL();

   255 

   256 	virtual void RestoreListL();

   257 

   258 private:

   259 	CMobilePhoneCBList* iResults;

   260 	TPckgBuf<TGetCallBarringRequest> iCBRequestData;

   261 	TInt iListExtensionId;

   262 	};

   263 

   264 

   265 

   266 

   267 class CRetrieveMobilePhoneCWList : public CAsyncRetrievePhoneList

   268 /**

   269 Retrieves the Call Waiting status list from the phone.

   270 

   271 Due to the probable time taken to retrieve a list, clients must use an asynchronous 

   272 approach based around the use this object.

   273 

   274 @publishedPartner

   275 @released

   276 */

   277 	{

   278 public:

   279 

   280 	// for use by client-side API code and TSY only

   281 

   282 	struct TGetCallWaitingRequest

   283 		{

   284 		RMobilePhone::TClientId iClient;

   285 		RMobilePhone::TMobileInfoLocation iLocation;

   286 		};

   287 

   288 public:

   289 	IMPORT_C static CRetrieveMobilePhoneCWList* NewL(RMobilePhone& aPhone);

   290 	IMPORT_C ~CRetrieveMobilePhoneCWList();

   291 

   292 	IMPORT_C void Start(TRequestStatus& aReqStatus,RMobilePhone::TMobileInfoLocation aLocation = RMobilePhone::EInfoLocationCachePreferred);

   293 

   294 	IMPORT_C CMobilePhoneCWList* RetrieveListL();

   295 

   296 protected:

   297 	CRetrieveMobilePhoneCWList(RMobilePhone& aPhone);

   298 	void ConstructL();

   299 

   300 	virtual void RestoreListL();

   301 

   302 private:

   303 	CMobilePhoneCWList* iResults;

   304 	TPckgBuf<TGetCallWaitingRequest> iCWRequestData;

   305 	};

   306 

   307 

   308 

   309 class CRetrieveMobilePhoneCcbsList : public CAsyncRetrievePhoneList

   310 /** Retrieve a list of all active CCBS requests from the phone.

   311 

   312 Each CCBS request will be represented by an entry in CMobilePhoneCcbsList. 

   313 The client is able to use the member functions of this class to enumerate 

   314 and read the CCBS request entries.

   315 

   316 Due to the probable time taken to retrieve a list, clients must use an asynchronous 

   317 approach based around the use of CRetrieveMobilePhoneCcbsList.

   318 

   319 @publishedPartner

   320 @released

   321 */

   322 	{

   323 public:

   324 	IMPORT_C static CRetrieveMobilePhoneCcbsList* NewL(RMobilePhone& aPhone);

   325 	IMPORT_C ~CRetrieveMobilePhoneCcbsList();

   326 

   327 	IMPORT_C void Start(TRequestStatus& aReqStatus);

   328 

   329 	IMPORT_C CMobilePhoneCcbsList* RetrieveListL();

   330 

   331 protected:

   332 	CRetrieveMobilePhoneCcbsList(RMobilePhone& aPhone);

   333 	void ConstructL();

   334 

   335 	virtual void RestoreListL();

   336 

   337 private:

   338 	CMobilePhoneCcbsList* iResults;

   339 	};

   340 

   341 

   342 

   343 class CRetrieveMobilePhoneSmsList : public CAsyncRetrieveStoreList

   344 /** Reads stored, fixed length SMS message list from the phone or SIM message store

   345 

   346 Instead of reading each message individually, a client may be able to retrieve 

   347 multiple messages currently stored in one go. This functionality will be available 

   348 if the TSY supports reading all SMS. The SMS storage capabilities are returned 

   349 within the iCaps field of RMobilePhoneStore::TMobilePhoneStoreInfoV1 and this 

   350 will inform a client what type(s) of storage access the TSY supports. These 

   351 capabilities will also indicate whether the SMS store contains GSM/WCDMA or 

   352 CDMA SMS messages. When all SMS entries in a store are read in one go, a list 

   353 (CMobilePhoneGsmSmsList or CMobilePhoneCdmaSmsList) object will be returned 

   354 to the client. This object will contain the message entries and the client

   355 is able to use the function members of the list class to enumerate and read 

   356 the message entries. 

   357 

   358 Due to the probable time taken to retrieve a list, clients must use an asynchronous 

   359 approach based around the use of this object. 

   360 

   361 @publishedPartner

   362 @released

   363 */

   364 	{

   365 public:

   366 	IMPORT_C static CRetrieveMobilePhoneSmsList* NewL(RMobilePhoneStore& aStore, RMobileSmsStore::TMobileSmsEntryExtensionId aType);

   367 	IMPORT_C ~CRetrieveMobilePhoneSmsList();

   368 

   369 	enum

   370 		{

   371 		KValueNotUsed = -1

   372 		};

   373 

   374 	struct TBatchRequestData

   375 		{

   376 		RMobilePhone::TClientId iClient;

   377 		RMobileSmsStore::TMobileSmsEntryExtensionId iEntryType;

   378 		TBool iBatchRequest;

   379 		TInt iStartIndex;

   380 		TInt iBatchSize;

   381 		};

   382 		

   383 	IMPORT_C void Start(TRequestStatus& aReqStatus);

   384 	IMPORT_C void StartBatch(TRequestStatus& aReqStatus, TInt aStartIndex, TInt aBatchSize);

   385 

   386 	IMPORT_C CMobilePhoneGsmSmsList* RetrieveGsmListL();

   387 	/* 

   388 	 @deprecated 9.5	  

   389 	 */

   390 	IMPORT_C CMobilePhoneCdmaSmsList* RetrieveCdmaListL();

   391 

   392 protected:

   393 	CRetrieveMobilePhoneSmsList(RMobilePhoneStore& aStore, RMobileSmsStore::TMobileSmsEntryExtensionId aType);

   394 	void ConstructL();

   395 	void InitiateRequest(TRequestStatus& aReqStatus, TBool aBatch, TInt aStartIndex, TInt aBatchSize);

   396 

   397 	virtual void RestoreListL();

   398 

   399 private:

   400 	CMobilePhoneGsmSmsList* iGsmResults;

   401 	CMobilePhoneCdmaSmsList* iCdmaResults;

   402 	RMobileSmsStore::TMobileSmsEntryExtensionId iEntryType;

   403 	TPckgBuf<TBatchRequestData> iRequestData;

   404 	};

   405 

   406 

   407 

   408 class CRetrieveMobilePhoneSmspList : public CAsyncRetrieveWithClientIds

   409 /** Reads SMS parameter list from the SIM's SMSP store.

   410 

   411 Instead of reading each SMSP entry individually, a client will retrieve all 

   412 the entries currently stored in one go. A list object (CMobilePhoneSmspList) 

   413 will be returned to the client. The list object that is returned to the client 

   414 will contain an entry for each set of SMS parameters.

   415 

   416 Due to the probable time taken to retrieve a list, clients must use an asynchronous 

   417 approach based around the use of this object. 

   418 

   419 @publishedPartner

   420 @released

   421 */

   422 	{

   423 public:

   424 	IMPORT_C static CRetrieveMobilePhoneSmspList* NewL(RMobileSmsMessaging& aMessaging);

   425 	IMPORT_C ~CRetrieveMobilePhoneSmspList();

   426 

   427 	IMPORT_C CMobilePhoneSmspList* RetrieveListL();

   428 	IMPORT_C void Start(TRequestStatus& aReqStatus);

   429 

   430 protected:

   431 	CRetrieveMobilePhoneSmspList(RMobileSmsMessaging& aMessaging);

   432 	void ConstructL();

   433 	virtual void RestoreListL();

   434 

   435 private:

   436 	virtual void Get(TInt aIpc, TRequestStatus& aReqStatus, TDes8& aDes1, TDes8& aDes2);

   437 	virtual void CancelReq(TInt aIpc1, TInt aIpc2);

   438 

   439 private:

   440 	RMobileSmsMessaging& iMessaging;

   441 	CMobilePhoneSmspList* iResults;

   442 	};

   443 

   444 

   445 

   446 class CRetrieveMobilePhoneBroadcastIdList : public CAsyncRetrieveWithClientIds

   447 /** Reads CBMI list from the phone. This list may be stored on SIM.

   448 

   449 Due to the probable time taken to retrieve a list, clients must use an asynchronous 

   450 approach based around the use of this class. 

   451 

   452 @publishedPartner

   453 @released

   454 */

   455 	{

   456 public:

   457 		// for use by client-side API code and TSY only

   458 

   459 	struct TGetBroadcastIdRequest

   460 		{

   461 		RMobileBroadcastMessaging::TMobileBroadcastIdType iIdType;

   462 		RMobilePhone::TClientId iClient;

   463 		};

   464 

   465 public:

   466 	IMPORT_C static CRetrieveMobilePhoneBroadcastIdList* NewL(RMobileBroadcastMessaging& aMessaging);

   467 	IMPORT_C ~CRetrieveMobilePhoneBroadcastIdList();

   468 

   469 	IMPORT_C CMobilePhoneBroadcastIdList* RetrieveListL();

   470 	IMPORT_C void Start(TRequestStatus& aReqStatus, RMobileBroadcastMessaging::TMobileBroadcastIdType aIdType);

   471 

   472 protected:

   473 	CRetrieveMobilePhoneBroadcastIdList(RMobileBroadcastMessaging& aMessaging);

   474 	void ConstructL();

   475 	virtual void RestoreListL();

   476 

   477 private:

   478 	virtual void Get(TInt aIpc, TRequestStatus& aReqStatus, TDes8& aDes1, TDes8& aDes2);

   479 	virtual void CancelReq(TInt aIpc1, TInt aIpc2);

   480 

   481 protected:

   482 	RMobileBroadcastMessaging& iMessaging;

   483 	CMobilePhoneBroadcastIdList* iResults;

   484 	TPckgBuf<TGetBroadcastIdRequest> iBroadcastIdRequestData;

   485 	};

   486 

   487 

   488 

   489 class CRetrieveMobilePhoneNamList : public CAsyncRetrieveStoreList

   490 /** The phone's NAM store.

   491 

   492 Instead of reading each NAM entry individually, a client may be able to retrieve 

   493 all the parameters in one NAM in one go.

   494 

   495 This functionality will be available if the TSY supports reading all entries 

   496 in one NAM. The NAM storage capabilities are returned within the iCaps field 

   497 of RMobilePhoneStore::TMobilePhoneStoreInfoV1 and this will inform a client 

   498 what type(s) of storage access the TSY supports. When all entries in one NAM 

   499 are read in one go, a CMobilePhoneNamList object will be returned to the client.

   500 

   501 Due to the probable time taken to retrieve a list, clients must use an asynchronous 

   502 approach based around the use of this object. 

   503 

   504 @publishedPartner

   505 @released

   506 */

   507 	{

   508 public:

   509 	IMPORT_C static CRetrieveMobilePhoneNamList* NewL(RMobilePhoneStore& aStore);

   510 	IMPORT_C ~CRetrieveMobilePhoneNamList();

   511 

   512 	struct TNamRequestData

   513 		{

   514 		RMobilePhone::TClientId iClient;

   515 		TInt iNamId;

   516 		};

   517 

   518 	IMPORT_C CMobilePhoneNamList* RetrieveListL();

   519 	IMPORT_C CMobilePhoneNamListV4* RetrieveListV4L();

   520 	IMPORT_C void Start(TRequestStatus& aReqStatus, TInt aNamId);

   521 	IMPORT_C void StartV4(TRequestStatus& aReqStatus, TInt aNamId);

   522 

   523 protected:

   524 	CRetrieveMobilePhoneNamList(RMobilePhoneStore& aStore);

   525 	void ConstructL();

   526 	

   527 	virtual void RestoreListL();

   528 

   529 private:

   530 	/* pointer to results containing V1 NAM list */

   531 	CMobilePhoneNamList* iResults;

   532 	/* pointer to results containing V4 NAM list */	

   533 	CMobilePhoneNamListV4* iResultsV4;

   534 	/* will be KETelExtMultimodeV1 if results are currently a V1 NAM list,

   535 	   KETelExtMultimodeV4 if they are currently a V4 NAM list */

   536 	TInt iListExtensionId;

   537 	TPckgBuf<TNamRequestData> iRequestData;

   538 	};

   539 

   540 

   541 class CRetrieveMobilePhoneONList : public CAsyncRetrieveStoreList

   542 /**

   543 Reads Own Number list from the phone or SIM's Own Number store.

   544 

   545 Instead of reading each own number entry individually, a client may be able 

   546 to retrieve all the own numbers in one go.

   547 

   548 This functionality will be available if the own number store's capabilities 

   549 include KCapsWholeStore. These capabilities are returned within the iCaps 

   550 field of RMobilePhoneStore::TMobilePhoneStoreInfoV1 and this will inform a 

   551 client what type(s) of storage access the TSY supports for that store.

   552 

   553 When all entries in own number store are read in one go, a CMobilePhoneONList 

   554 object will be returned to the client. 

   555 

   556 Due to the probable time taken to retrieve a list, clients must use an asynchronous 

   557 approach based around the use of this object. 

   558 

   559 @publishedPartner

   560 @released

   561 */

   562 	{

   563 public:

   564 	IMPORT_C static CRetrieveMobilePhoneONList* NewL(RMobilePhoneStore& aStore);

   565 	IMPORT_C ~CRetrieveMobilePhoneONList();

   566 

   567 	IMPORT_C CMobilePhoneONList* RetrieveListL();

   568 	IMPORT_C void Start(TRequestStatus& aReqStatus);

   569 

   570 protected:

   571 	CRetrieveMobilePhoneONList(RMobilePhoneStore& aStore);

   572 	void ConstructL();

   573 	

   574 	virtual void RestoreListL();

   575 

   576 private:

   577 	CMobilePhoneONList* iResults;

   578 	};

   579 

   580 

   581 

   582 class CRetrieveMobilePhoneENList : public CAsyncRetrieveStoreList

   583 /**

   584 Reads Emergency Number list from the phone or SIM store.

   585 

   586 Instead of reading each emergency number entry individually, a client may be 

   587 able to retrieve all the numbers in one go from SIM and/or NAM.

   588 

   589 This functionality will be available if the TSY supports reading all entries 

   590 in one go. The emergency number store's capabilities are returned within the 

   591 iCaps field of RMobilePhoneStore::TMobilePhoneStoreInfoV1 and this will inform 

   592 a client what type(s) of storage access the TSY supports.

   593 

   594 When all entries in SIM and/or NAM are read in one go, a CMobilePhoneENList 

   595 object will be returned to the client. The CMobilePhoneENList object that

   596 is returned to the client will contain the SIM and/or NAM entries and the 

   597 client is able to use the function members of CMobilePhoneENList to enumerate 

   598 and read the entries.

   599 

   600 Due to the probable time taken to retrieve a list, clients must use an asynchronous 

   601 approach based around the use of this object. 

   602 

   603 @publishedPartner

   604 @released

   605 */

   606 	{

   607 public:

   608 	IMPORT_C static CRetrieveMobilePhoneENList* NewL(RMobilePhoneStore& aStore);

   609 	IMPORT_C ~CRetrieveMobilePhoneENList();

   610 

   611 	IMPORT_C CMobilePhoneENList* RetrieveListL();

   612 	IMPORT_C void Start(TRequestStatus& aReqStatus);

   613 

   614 protected:

   615 	CRetrieveMobilePhoneENList(RMobilePhoneStore& aStore);

   616 	void ConstructL();

   617 

   618 	virtual void RestoreListL();

   619 

   620 private:

   621 	CMobilePhoneENList* iResults;

   622 	};

   623 

   624 class  CRetrieveMobilePhonePreferredNetworks  : public CAsyncRetrievePhoneList

   625 /**

   626 Retrieves the preferred stored network list from the USIM.

   627 

   628 @publishedPartner

   629 @released

   630 */

   631 	{

   632 public:

   633 	IMPORT_C static CRetrieveMobilePhonePreferredNetworks* NewL(RMobilePhone& aPhone);

   634 	IMPORT_C ~CRetrieveMobilePhonePreferredNetworks();

   635 

   636 	IMPORT_C CMobilePhoneStoredNetworkList* RetrieveListL();

   637 	IMPORT_C void Start(TRequestStatus& aReqStatus);

   638 

   639 protected:

   640 	CRetrieveMobilePhonePreferredNetworks(RMobilePhone& aPhone);

   641 	void ConstructL();

   642 

   643 	virtual void RestoreListL();

   644 

   645 private:

   646 	CMobilePhoneStoredNetworkList* iResults;

   647 	};

   648 

   649 /**

   650 Class used to retrieve authorization data from the ISIM/USIM.

   651 

   652 It inherits from CAsyncRetrieveVariableLengthBufferV2, active object derived class that

   653 enables retrieval of data of variable length - length of data is retrieved by

   654 the first IPC it issues, and actual data via second IPC.

   655 

   656 @publishedPartner

   657 @released

   658 */

   659 NONSHARABLE_CLASS(CAsyncRetrieveAuthorizationInfo) : public CAsyncRetrieveVariableLengthBufferV2

   660 	{

   661 public:

   662 	IMPORT_C static CAsyncRetrieveAuthorizationInfo* NewL(RMobilePhone& aPhone,RMobilePhone::CImsAuthorizationInfoV5& authInfo);

   663 	IMPORT_C void Start(TRequestStatus& aReqStatus);

   664 	IMPORT_C TBool AuthInfoValid()const;

   665 	

   666 protected:

   667 	void Get(TInt aIpc, TRequestStatus& aReqStatus, TDes8& aDes1, TDes8& aDes2);

   668 	void CancelReq(TInt aIpc1, TInt aIpc2);

   669 	void RestoreListL();	

   670 	CAsyncRetrieveAuthorizationInfo(RMobilePhone& aPhone,RMobilePhone::CImsAuthorizationInfoV5& authInfo);

   671 	/** reference of the phone object whom this API refers to*/

   672 	RMobilePhone& iPhone;

   673 	/** external authorization data to be populated by use of the API provided by this class*/

   674 	RMobilePhone::CImsAuthorizationInfoV5& iAuthInfo;

   675 	/** indicates whether iAuthInfo data member is valid - data from ISIM/USIM retrieved */ 

   676 	TBool iAuthInfoValid;

   677 	/** identifies client that issued original request*/

   678 	TPckgBuf<RMobilePhone::TClientId> iId;

   679 	};

   680 

   681 /**

   682 One CAsyncSmartCardEapAuthentication object should be used per EAP

   683 packet that the client wishes to send to the EAP-capable smart card

   684 application.  The Packets can be EAP-Challenges, Identity requests,

   685 Success packets, etc..  Subsequently, this object can be used to

   686 retrieve the corresponding response data given by the DF_EAP.

   687 

   688 (See RFC3748 and section 6.1 of ETSI TS 102.310 v6.2.0.)

   689 

   690 @see RMobileSmartCardEap

   691 */

   692 class CAsyncSmartCardEapAuthentication : public CAsyncRetrieveVariableLengthBufferV2

   693 	{

   694 public:

   695 	IMPORT_C static CAsyncSmartCardEapAuthentication* NewL(RMobileSmartCardEap& aScEap, const TDesC8& aEapRequestPckt);

   696 	IMPORT_C void Start(TRequestStatus& aReqStatus);

   697 	IMPORT_C TDesC8& RetrieveEapResponse();

   698 	IMPORT_C ~CAsyncSmartCardEapAuthentication();

   699 

   700 private:

   701 	CAsyncSmartCardEapAuthentication(RMobileSmartCardEap& aScEap);

   702 	void ConstructL(const TDesC8& aEapRequestPckt);

   703 	virtual void CancelReq(TInt aIpc1, TInt aIpc2);

   704 	virtual void Get(TInt aIpc, TRequestStatus& aReqStatus, TDes8& aDes1, TDes8& aDes2);

   705 

   706 private:

   707 	/**

   708 	The sub-session that this object will use for the retrieval.

   709 	*/

   710 	RMobileSmartCardEap& iSmartCardEap;

   711 	/**

   712 	The serialised data holder for the EAP request packet.

   713 	*/

   714 	RMobileSmartCardEap::CEapAuthenticateRequestDataV6* iReqData;

   715 	};

   716 

   717 class CRetrieveMobilePhoneAuthenticationIds : public CAsyncRetrievePhoneList

   718 /** Reads stored fixed length Authentication GBA and MBMS list (EF_GBANL and EF_MSK)

   719  from the phone.

   720 

   721 Instead of reading each list individually, a client may be able to retrieve 

   722 multiple lists currently stored in one go. This functionality will be available 

   723 if the TSY supports reading both Authentication GBA and MBMS list. 

   724 When all authentication list entries are read in one go, a list 

   725 (CMobilePhoneGbaNafIdList or CMobilePhoneMbmsMskIdList) object will be returned 

   726 to the client.This object will contain the authentication entries and the client

   727 is able to use the function members of the list class to enumerate and read 

   728 the message entries. 

   729 

   730 Due to the probable time taken to retrieve a list, clients must use an asynchronous 

   731 approach based around the use of this object. 

   732 

   733 @publishedPartner

   734 @released

   735 */	{

   736 public:

   737 	IMPORT_C static CRetrieveMobilePhoneAuthenticationIds* NewL(RMobilePhone& aPhone);

   738 	IMPORT_C ~CRetrieveMobilePhoneAuthenticationIds();

   739 	IMPORT_C void Start(TRequestStatus& aReqStatus, const TDesC8& aData);

   740 

   741 	IMPORT_C CMobilePhoneGbaNafIdList* RetrieveGbaListL();

   742 	IMPORT_C CMobilePhoneMbmsMskIdList* RetrieveMbmsListL();

   743 

   744 	struct TAuthRequestData

   745 		{

   746 		RMobilePhone::TClientId iClient;

   747 		RMobilePhone::TAuthInfoV8	iAuthInfo;

   748 		};

   749 		

   750 protected:

   751 	CRetrieveMobilePhoneAuthenticationIds(RMobilePhone& aPhone);

   752 	void ConstructL();

   753 	virtual void RestoreListL();

   754 	

   755 private:

   756 	CMobilePhoneGbaNafIdList* iGbaNafIdResults;

   757 	CMobilePhoneMbmsMskIdList* iMbmsMskIdResults;

   758 	RMobilePhone::TAuthData iListType;

   759 	TPckgBuf<TAuthRequestData> iAuthRequestData;

   760 	};

   761 

   762 class CRetrieveMobilePhonePreferredWlanSIDs : public CAsyncRetrievePhoneList

   763 /**

   764 Retrieves the Wlan Specific identifier list(user/Operator Controlled) from the USIM.

   765 

   766 @see RMobilePhone::TWlanSIDV8

   767 

   768 @publishedPartner

   769 @released

   770 */

   771 	{

   772 public:

   773 	IMPORT_C static CRetrieveMobilePhonePreferredWlanSIDs* NewL(RMobilePhone& aPhone);

   774 	IMPORT_C ~CRetrieveMobilePhonePreferredWlanSIDs();

   775 	

   776 	IMPORT_C CMobilePhoneStoredWlanSIDList* RetrieveListL();

   777 	IMPORT_C void Start(TRequestStatus& aReqStatus);

   778 	

   779 protected:

   780 	CRetrieveMobilePhonePreferredWlanSIDs(RMobilePhone& aPhone);

   781 	void ConstructL();

   782 	virtual void RestoreListL();

   783 	

   784 private:

   785 	CMobilePhoneStoredWlanSIDList* iResults;

   786 	};

   787 

   788 #endif // _MMRETRIEVE_H_