|
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_ |