|
1 // Copyright (c) 1997-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 // \file MPHBKINF.CPP |
|
15 // Multimode TSY Phone book Implementation file. |
|
16 // This file contains the implementation of the CATPhoneBookInfo class, which is used |
|
17 // to obtain Phone book information. |
|
18 // This class does all three AT+CPBS commands and an AT+CPBR: |
|
19 // AT+CPBS=? to get the supported storage types; |
|
20 // AT+CPBS=<storage> to set the storage type; |
|
21 // AT+CPBS? to get the 'used' and 'total' slots; |
|
22 // AT+CPBR=? to get the maximum length of the number and text fields; |
|
23 // A TPhoneBookInfo struct containing all the relevant information about the |
|
24 // specified phone book is returned. |
|
25 // |
|
26 // |
|
27 |
|
28 |
|
29 #include "Mphbkcom.h" |
|
30 #include "mSLOGGER.H" |
|
31 #include "mPHBOOK.H" |
|
32 #include "ATIO.H" |
|
33 #include "Matstd.h" |
|
34 #include "mphbkinf.h" |
|
35 |
|
36 |
|
37 // AT command |
|
38 _LIT8(KPhoneBookReadTest,"AT+CPBR=?"); |
|
39 |
|
40 // |
|
41 const TUint KHyphenChar='-'; |
|
42 |
|
43 // |
|
44 GLDEF_C void ConvertStorageTypeToName(const TStorageType& aStorageType,TDes& aName) |
|
45 /** |
|
46 * This function converts a storage type (phone book memory) to its name equivalent. |
|
47 */ |
|
48 { |
|
49 if (aStorageType==KFDStorage) |
|
50 aName.Copy(KETelIccFdnPhoneBook); |
|
51 else if (aStorageType==KMEStorage) |
|
52 aName.Copy(KETelMeAdnPhoneBook); |
|
53 else if (aStorageType==KMTStorage) |
|
54 aName.Copy(KETelCombinedAdnPhoneBook); |
|
55 else if (aStorageType==KSMStorage) |
|
56 aName.Copy(KETelIccAdnPhoneBook); |
|
57 else if (aStorageType==KTAStorage) |
|
58 aName.Copy(KETelTaAdnPhoneBook); |
|
59 else if (aStorageType==KBMStorage) |
|
60 aName.Copy(KETelIccBdnPhoneBook); |
|
61 else if (aStorageType==KDCStorage) |
|
62 aName.Copy(KETelMeDialledPhoneBook); |
|
63 else if (aStorageType==KENStorage) |
|
64 aName.Copy(KETelEmergencyNumberStore); |
|
65 else if (aStorageType==KMCStorage) |
|
66 aName.Copy(KETelMeMissedPhoneBook); |
|
67 else if (aStorageType==KRCStorage) |
|
68 aName.Copy(KETelMeReceivedPhoneBook); |
|
69 else if (aStorageType==KLDStorage) |
|
70 aName.Copy(KETelIccLndPhoneBook); |
|
71 else if (aStorageType==KONStorage) |
|
72 aName.Copy(KETelOwnNumberStore); |
|
73 else if (aStorageType==KSNStorage) |
|
74 aName.Copy(KETelIccSdnPhoneBook); |
|
75 else |
|
76 // we don't know any other storage type |
|
77 aName.SetLength(0); |
|
78 } |
|
79 |
|
80 // |
|
81 // CATPhoneBookInfo Implementation |
|
82 // |
|
83 |
|
84 CATPhoneBookInfo* CATPhoneBookInfo::NewL(CATIO* aIo,CTelObject* aTelObject,CATInit* aInit,CPhoneGlobals* aPhoneGlobals) |
|
85 /** |
|
86 * Standard 2 phase constructor. |
|
87 */ |
|
88 { |
|
89 CATPhoneBookInfo* r=new(ELeave) CATPhoneBookInfo(aIo,aTelObject,aInit,aPhoneGlobals); |
|
90 CleanupStack::PushL(r); |
|
91 r->ConstructL(); |
|
92 CleanupStack::Pop(); |
|
93 return r; |
|
94 } |
|
95 |
|
96 CATPhoneBookInfo::CATPhoneBookInfo(CATIO* aIo,CTelObject* aTelObject,CATInit* aInit,CPhoneGlobals* aPhoneGlobals) |
|
97 : CATCommands(aIo,aTelObject,aInit,aPhoneGlobals), iCompleted(EFalse) |
|
98 { |
|
99 } |
|
100 |
|
101 CATPhoneBookInfo::~CATPhoneBookInfo() |
|
102 /** |
|
103 * Destructor. |
|
104 */ |
|
105 { |
|
106 delete iStorageTypeArray; |
|
107 } |
|
108 |
|
109 void CATPhoneBookInfo::ConstructL() |
|
110 /** |
|
111 * This function calls the ConstructL() function of the CATCommands class. |
|
112 * It also allocates memory for an array of supported phonebook types. |
|
113 */ |
|
114 { |
|
115 CATCommands::ConstructL(); |
|
116 iStorageTypeArray=new(ELeave) CArrayFixFlat<TStorageType>(5); |
|
117 } |
|
118 |
|
119 void CATPhoneBookInfo::Start(TTsyReqHandle aTsyReqHandle,TAny* aParams) |
|
120 /** |
|
121 * Start function; initializes TPhoneBookInfo struct members to Unknown |
|
122 * and starts the AT+CPBS? query command. |
|
123 */ |
|
124 { |
|
125 LOGTEXT(_L8("Starting AT+CPBS? Command")); |
|
126 |
|
127 iReqHandle=aTsyReqHandle; |
|
128 |
|
129 if (aParams) |
|
130 iInfoPckg=static_cast<RMobilePhoneStore::TMobilePhoneStoreInfoV1Pckg*>(aParams); |
|
131 |
|
132 // if this is the first time then get a list of the supported types, otherwise, just |
|
133 // get info for the required index |
|
134 |
|
135 if (iStorageTypeArray->Count()>0) |
|
136 { |
|
137 SetIndexByStorageType(); |
|
138 StartSelect(); |
|
139 } |
|
140 else |
|
141 { |
|
142 WriteExpectingResults(KPhoneBookStorageTest(),3); |
|
143 __ASSERT_ALWAYS(iIo->AddExpectString(this,KNotifyMeIfErrorString) != NULL, Panic(EGeneral)); |
|
144 iState=EListWaitForWriteComplete; |
|
145 } |
|
146 } |
|
147 |
|
148 void CATPhoneBookInfo::EventSignal(TEventSource aEventSource) |
|
149 /** |
|
150 * This function contains the State machine for retrieving phone book information. |
|
151 * |
|
152 * Waits for the AT+CPBS=? command to be written to the comm port, parses the phone's |
|
153 * response and initializes an array containing the supported phone book memories. It |
|
154 * then sets a phonebook type, and retrieves information pertaining to the phone book: |
|
155 * total no. of slots, no. of used slots, the maximum length of the text and number fields. |
|
156 */ |
|
157 { |
|
158 LOGTEXT2(_L8("CATPhoneBookInfo::EventSignal, aEventSource=%d"),aEventSource); |
|
159 |
|
160 if (aEventSource==ETimeOutCompletion) |
|
161 { |
|
162 LOGTEXT(_L8("Timeout Error during getting phone book info")); |
|
163 RemoveStdExpectStrings(); |
|
164 Complete(KErrTimedOut,aEventSource); |
|
165 return; |
|
166 } |
|
167 |
|
168 switch (iState) |
|
169 { |
|
170 case EListWaitForWriteComplete: |
|
171 WriteComplete(aEventSource,EListWaitForReadComplete); |
|
172 LOGTEXT(_L8("CATPhoneBookInfo::EventSignal processed EListWaitForWriteComplete")); |
|
173 break; |
|
174 |
|
175 case EListWaitForReadComplete: |
|
176 __ASSERT_ALWAYS(aEventSource==EReadCompletion,Panic(EATCommand_IllegalCompletionReadExpected)); |
|
177 { |
|
178 TInt ret(ValidateExpectString()); |
|
179 RemoveStdExpectStrings(); |
|
180 if (ret!=KErrNone) |
|
181 { |
|
182 Complete(ret,aEventSource); |
|
183 return; |
|
184 } |
|
185 TRAP(ret,ParseListResponseL()); // parse the list of supported phone book types. |
|
186 if (ret!=KErrNone) |
|
187 { |
|
188 Complete(ret,aEventSource); |
|
189 return; |
|
190 } |
|
191 } |
|
192 SetIndexByStorageType(); |
|
193 StartSelect(); // Set a phone book memory. |
|
194 LOGTEXT(_L8("CATPhoneBookInfo::EventSignal processed EListWaitForReadComplete")); |
|
195 break; |
|
196 |
|
197 case ESelectWaitForWriteComplete: |
|
198 WriteComplete(aEventSource,ESelectWaitForReadComplete); |
|
199 LOGTEXT(_L8("CATPhoneBookInfo::EventSignal processed ESelectWaitForWriteComplete")); |
|
200 break; |
|
201 |
|
202 case ESelectWaitForReadComplete: |
|
203 __ASSERT_ALWAYS(aEventSource==EReadCompletion,Panic(EATCommand_IllegalCompletionReadExpected)); |
|
204 { |
|
205 TInt ret(ValidateExpectString()); |
|
206 RemoveStdExpectStrings(); |
|
207 if (ret!=KErrNone) |
|
208 { |
|
209 Complete(ret,aEventSource); |
|
210 return; |
|
211 } |
|
212 // no parsing this time |
|
213 } |
|
214 iPhoneGlobals->iPhoneStatus.iLastAccessedPhoneBook=iStorageType; |
|
215 StartGetInfo(); // Transmit AT+CPBS? cmd; get the phone book's total and used slots |
|
216 LOGTEXT(_L8("CATPhoneBookInfo::EventSignal processed ESelectWaitForReadComplete")); |
|
217 break; |
|
218 |
|
219 case EGetInfoWaitForWriteComplete: |
|
220 WriteComplete(aEventSource,EGetInfoWaitForReadComplete); |
|
221 LOGTEXT(_L8("CATPhoneBookInfo::EventSignal processed EGetInfoWaitForWriteComplete")); |
|
222 break; |
|
223 |
|
224 case EGetInfoWaitForReadComplete: |
|
225 __ASSERT_ALWAYS(aEventSource==EReadCompletion,Panic(EATCommand_IllegalCompletionReadExpected)); |
|
226 { |
|
227 TInt ret(ValidateExpectString()); |
|
228 RemoveStdExpectStrings(); |
|
229 if (ret!=KErrNone) |
|
230 { |
|
231 Complete(ret,aEventSource); |
|
232 return; |
|
233 } |
|
234 TRAP(ret,ParseGetInfoResponseL()); // Parse the phone's response to the AT+CPBS? command |
|
235 if (ret!=KErrNone) |
|
236 { |
|
237 Complete(ret,aEventSource); |
|
238 return; |
|
239 } |
|
240 } |
|
241 StartGetMaxLength(); // Transmit AT+CPBR=? cmd; get the maximum text and number length. |
|
242 LOGTEXT(_L8("CATPhoneBookInfo::EventSignal processed EGetInfoWaitForReadComplete")); |
|
243 break; |
|
244 |
|
245 case EGetMaxLengthWaitForWriteComplete: |
|
246 WriteComplete(aEventSource,EGetMaxLengthWaitForReadComplete); |
|
247 LOGTEXT(_L8("CATPhoneBookInfo::EventSignal processed EGetMaxLengthWaitForWriteComplete")); |
|
248 break; |
|
249 |
|
250 case EGetMaxLengthWaitForReadComplete: |
|
251 __ASSERT_ALWAYS(aEventSource==EReadCompletion,Panic(EATCommand_IllegalCompletionReadExpected)); |
|
252 { |
|
253 TInt ret(ValidateExpectString()); |
|
254 RemoveStdExpectStrings(); |
|
255 if (ret!=KErrNone) |
|
256 { |
|
257 Complete(ret,aEventSource); |
|
258 return; |
|
259 } |
|
260 TRAP(ret,ParseGetMaxLengthResponseL()); // Parse the phone's response to the AT+CPBR=? command. |
|
261 Complete(ret,aEventSource); |
|
262 } |
|
263 LOGTEXT(_L8("CATPhoneBookInfo::EventSignal processed EGetMaxLengthWaitForReadComplete")); |
|
264 break; |
|
265 |
|
266 case EIdle: |
|
267 default: |
|
268 break; |
|
269 } |
|
270 } |
|
271 |
|
272 void CATPhoneBookInfo::CompleteWithIOError(TEventSource /*aSource*/,TInt aStatus) |
|
273 /** |
|
274 * This function is called if an error occurs. It cancels the relevant timer and |
|
275 * completes the request before setting the state to Idle. |
|
276 */ |
|
277 { |
|
278 if (iState!=EIdle) |
|
279 { |
|
280 iIo->WriteAndTimerCancel(this); |
|
281 if (iReqHandle) |
|
282 { |
|
283 iTelObject->ReqCompleted(iReqHandle,aStatus); |
|
284 } |
|
285 iState=EIdle; |
|
286 } |
|
287 } |
|
288 |
|
289 void CATPhoneBookInfo::SetStorageType(TStorageType aStorageType) |
|
290 /** |
|
291 * Sets the client's desired phonebook type. |
|
292 */ |
|
293 { |
|
294 iStorageType=aStorageType; |
|
295 } |
|
296 |
|
297 void CATPhoneBookInfo::SetIndexByStorageType() |
|
298 /** |
|
299 * Sets the client index using the storage type supplied by the client |
|
300 */ |
|
301 { |
|
302 iIndex=KErrUnknown; |
|
303 for (TInt i=0; i<iStorageTypeArray->Count(); i++) |
|
304 { |
|
305 if ((*iStorageTypeArray)[i] == iStorageType) |
|
306 { |
|
307 iIndex=i; |
|
308 return; |
|
309 } |
|
310 } |
|
311 } |
|
312 |
|
313 void CATPhoneBookInfo::Stop(TTsyReqHandle aTsyReqHandle) |
|
314 /** |
|
315 * This function is used to prematurely stop the state machine. This would usually |
|
316 * occur following a client cancel request. |
|
317 */ |
|
318 { |
|
319 __ASSERT_ALWAYS(aTsyReqHandle == iReqHandle,Panic(EIllegalTsyReqHandle)); |
|
320 LOGTEXT(_L8("Cancelling phone book get info command")); |
|
321 |
|
322 switch (iState) |
|
323 { |
|
324 case EListWaitForWriteComplete: |
|
325 case ESelectWaitForWriteComplete: |
|
326 case EGetInfoWaitForWriteComplete: |
|
327 case EGetMaxLengthWaitForWriteComplete: |
|
328 Complete(KErrCancel,EWriteCompletion); |
|
329 return; |
|
330 |
|
331 case EListWaitForReadComplete: |
|
332 case ESelectWaitForReadComplete: |
|
333 case EGetInfoWaitForReadComplete: |
|
334 case EGetMaxLengthWaitForReadComplete: |
|
335 Complete(KErrCancel,EReadCompletion); |
|
336 return; |
|
337 |
|
338 case EIdle: |
|
339 default: |
|
340 return; |
|
341 } |
|
342 } |
|
343 |
|
344 |
|
345 void CATPhoneBookInfo::StartSelect() |
|
346 /** |
|
347 * This function selects a phonebook memory. |
|
348 */ |
|
349 { |
|
350 TBuf8<KGenericBufferSize> buf; |
|
351 |
|
352 if (iPhoneGlobals->iPhoneStatus.iLastAccessedPhoneBook!=iStorageType) |
|
353 { |
|
354 // We need to select the phonebook using AT+CPBS=<storage> |
|
355 if (iIndex>=0) |
|
356 buf.Format(KPhoneBookStorageSet,&(*iStorageTypeArray)[iIndex]); |
|
357 else |
|
358 Panic(EUnknownPhoneBookStorageTypeIndex); |
|
359 |
|
360 WriteExpectingResults(buf,3); |
|
361 __ASSERT_ALWAYS(iIo->AddExpectString(this,KNotifyMeIfErrorString) != NULL, Panic(EGeneral)); |
|
362 iState=ESelectWaitForWriteComplete; |
|
363 } |
|
364 else |
|
365 // We already have correct phonebook selected |
|
366 StartGetInfo(); |
|
367 } |
|
368 |
|
369 void CATPhoneBookInfo::StartGetInfo() |
|
370 /** |
|
371 * This function transmits an AT+CPBS? command. |
|
372 */ |
|
373 { |
|
374 WriteExpectingResults(KPhoneBookStorageRead(),3); |
|
375 |
|
376 __ASSERT_ALWAYS(iIo->AddExpectString(this,KNotifyMeIfErrorString) != NULL, Panic(EGeneral)); |
|
377 iState=EGetInfoWaitForWriteComplete; |
|
378 } |
|
379 |
|
380 void CATPhoneBookInfo::StartGetMaxLength() |
|
381 /** |
|
382 * This function transmits an AT+CPBR=? command. |
|
383 */ |
|
384 { |
|
385 WriteExpectingResults(KPhoneBookReadTest(),3); |
|
386 __ASSERT_ALWAYS(iIo->AddExpectString(this,KNotifyMeIfErrorString) != NULL, Panic(EGeneral)); |
|
387 iState=EGetMaxLengthWaitForWriteComplete; |
|
388 } |
|
389 |
|
390 void CATPhoneBookInfo::ParseListResponseL() |
|
391 /** |
|
392 * This function parses the phone's response to the AT+CPBS=? command. |
|
393 * It initializes an array with the supported phone book types. |
|
394 */ |
|
395 { |
|
396 TInt count=iStorageTypeArray->Count(); |
|
397 if (count>0) |
|
398 iStorageTypeArray->Delete(0,count); |
|
399 |
|
400 ParseBufferLC(EFalse, ':'); |
|
401 if (iRxResults.IsEmpty()) |
|
402 User::Leave(KErrNotFound); |
|
403 else |
|
404 { |
|
405 TDblQueIter<CATParamListEntry> iter(iRxResults); |
|
406 CATParamListEntry* entry=iter++; |
|
407 if (entry!=NULL) |
|
408 { |
|
409 entry->Deque(); // skip the +CPBS |
|
410 delete entry; |
|
411 } |
|
412 else |
|
413 User::Leave(KErrNotFound); |
|
414 |
|
415 entry=iter++; |
|
416 TStorageType storageType; |
|
417 while (entry!=NULL) |
|
418 { |
|
419 if (entry->iResultPtr.Length()>2) |
|
420 User::Leave(KErrArgument); |
|
421 storageType=entry->iResultPtr; |
|
422 iStorageTypeArray->AppendL(storageType); |
|
423 entry->Deque(); |
|
424 delete entry; |
|
425 entry=iter++; |
|
426 } |
|
427 } |
|
428 CleanupStack::PopAndDestroy(); // parsed buffer |
|
429 } |
|
430 |
|
431 void CATPhoneBookInfo::ParseGetInfoResponseL() |
|
432 /** |
|
433 * This function parses the phone's response to the AT+CPBS? command. |
|
434 * The variables containing the used and total slots are assigned the |
|
435 * corresponding values returned by the phone. |
|
436 */ |
|
437 { |
|
438 ParseBufferLC(EFalse, ':'); |
|
439 TDblQueIter<CATParamListEntry> iter(iRxResults); |
|
440 CATParamListEntry* entry=iter++; |
|
441 if (entry!=NULL) |
|
442 { |
|
443 entry->Deque(); // skip the +CPBS |
|
444 delete entry; |
|
445 } |
|
446 else |
|
447 User::Leave(KErrNotFound); |
|
448 |
|
449 entry=iter++; |
|
450 if (entry!=NULL) |
|
451 { |
|
452 entry->Deque(); // skip the storage name |
|
453 delete entry; |
|
454 } |
|
455 else |
|
456 User::Leave(KErrNotFound); |
|
457 |
|
458 entry=iter++; |
|
459 if (entry!=NULL) |
|
460 { |
|
461 CATParamListEntry::EntryValL(entry,iPhbkInfo.iUsedEntries); |
|
462 entry=iter++; |
|
463 } |
|
464 |
|
465 if (entry!=NULL) |
|
466 { |
|
467 CATParamListEntry::EntryValL(entry,iPhbkInfo.iTotalEntries); |
|
468 } |
|
469 |
|
470 CleanupStack::PopAndDestroy(); // parsed buffer |
|
471 } |
|
472 |
|
473 void CATPhoneBookInfo::ParseGetMaxLengthResponseL() |
|
474 /** |
|
475 * This function parses the phone's response to the AT+CPBR=? command -> e.g. |
|
476 * +CPBR: (101-200),020,014 or +CPBR: (1-10),32,14. |
|
477 * The variables containing the maximum text and number lengths are assigned |
|
478 * the corresponding values returned by the phone. |
|
479 */ |
|
480 { |
|
481 ParseBufferLC(EFalse, ':'); |
|
482 TDblQueIter<CATParamListEntry> iter(iRxResults); |
|
483 CATParamListEntry* entry=iter++; |
|
484 if (entry==NULL) |
|
485 User::Leave(KErrNotFound); |
|
486 |
|
487 // skip the +CPBR |
|
488 entry=iter++; |
|
489 |
|
490 // T28 returns CPBR:(),20,8. () should be tackled correctly. |
|
491 if (entry->iResultPtr.Locate(KHyphenChar)==KErrNotFound) |
|
492 entry=iter++; |
|
493 else |
|
494 { |
|
495 while (entry!=NULL && entry->iResultPtr.Locate(KHyphenChar)>KErrNone) |
|
496 { |
|
497 const TInt hyphenPos=entry->iResultPtr.Locate(KHyphenChar); |
|
498 TPtrC8 beforeHyphen=entry->iResultPtr.Left(hyphenPos); |
|
499 TPtrC8 afterHyphen=entry->iResultPtr.Mid(hyphenPos+1); |
|
500 |
|
501 // Get the index offset that'll need to be used for |
|
502 // read, write and delete phone book store operations |
|
503 { // curly brackets used to scope TLex8 object |
|
504 TLex8 lex(beforeHyphen); |
|
505 (void)User::LeaveIfError(lex.Val(iIndexOffset)); |
|
506 } |
|
507 iIndexOffset--; // decrement offset by one as it is an offset and not a starting index value |
|
508 |
|
509 LOGTEXT2(_L8("CATPhoneBookInfo::ParseGetMaxLengthResponseL iIndexOffset=%d"),iIndexOffset); |
|
510 |
|
511 if (iPhbkInfo.iTotalEntries<=0) |
|
512 { |
|
513 // The optional <used> and <total> parameters were not present in AT+CPBS=? |
|
514 // Try to get this info from AT+CPBR? instead |
|
515 TLex8 lex(afterHyphen); |
|
516 (void)User::LeaveIfError(lex.Val(iPhbkInfo.iTotalEntries)); |
|
517 } |
|
518 entry=iter++; |
|
519 } |
|
520 } |
|
521 |
|
522 if (entry!=NULL) |
|
523 { |
|
524 CATParamListEntry::EntryValL(entry,iPhbkInfo.iMaxNumLength); |
|
525 entry=iter++; |
|
526 } |
|
527 else |
|
528 // not supported by this ME |
|
529 iPhbkInfo.iMaxNumLength=KErrNotFound; |
|
530 |
|
531 if (entry!=NULL) |
|
532 CATParamListEntry::EntryValL(entry,iPhbkInfo.iMaxTextLength); |
|
533 else |
|
534 // not supported by this ME |
|
535 iPhbkInfo.iMaxTextLength=KErrNotFound; |
|
536 |
|
537 CleanupStack::PopAndDestroy(); // parsed buffer |
|
538 } |
|
539 |
|
540 void CATPhoneBookInfo::WriteComplete(TEventSource aSource,TPhoneBookInfoState aState) |
|
541 /** |
|
542 * This function is used by the Write states in the State machine. Performs common |
|
543 * write routines and sets the new state. |
|
544 */ |
|
545 { |
|
546 __ASSERT_ALWAYS(aSource==EWriteCompletion,Panic(EATCommand_IllegalCompletionWriteExpected)); |
|
547 AddStdExpectStrings(); |
|
548 iIo->SetTimeOut(this); |
|
549 iState=aState; |
|
550 } |
|
551 |
|
552 void CATPhoneBookInfo::Complete(TInt aError, TEventSource aSource) |
|
553 /** |
|
554 * This function completes the Client request. |
|
555 * It sets the Write Access for the phone book and sets the state to Idle. |
|
556 */ |
|
557 { |
|
558 LOGTEXT2(_L8("CATPhoneBookInfo::Complete aError=%d"),aError); |
|
559 |
|
560 if (aError==KErrNone) |
|
561 { |
|
562 iPhbkInfo.iCaps = RMobilePhoneStore::KCapsReadAccess; |
|
563 if (CPhoneGlobals::IsWriteAccess(iStorageType)) |
|
564 iPhbkInfo.iCaps |= RMobilePhoneStore::KCapsWriteAccess; |
|
565 |
|
566 ConvertStorageTypeToName(iStorageType, iPhbkInfo.iName); |
|
567 |
|
568 iIo->WriteAndTimerCancel(this); |
|
569 iIo->RemoveExpectStrings(this); |
|
570 |
|
571 iState=EIdle; |
|
572 // Mark the information retrieval as completed - so it is not repeated |
|
573 iCompleted=ETrue; |
|
574 |
|
575 // Write back data if started by a client request |
|
576 if (iReqHandle) |
|
577 { |
|
578 // Check if client was actually asking for RMobilePhoneStore::TMobilePhoneStoreInfoV1 |
|
579 // rather than larger RMobilePhonebookStore::TMobilePhoneBookInfoV1 |
|
580 |
|
581 RMobilePhoneStore::TMobilePhoneStoreInfoV1& storeInfo = (*iInfoPckg)(); |
|
582 |
|
583 storeInfo.iType=RMobilePhoneStore::EPhoneBookStore; |
|
584 storeInfo.iUsedEntries=iPhbkInfo.iUsedEntries; |
|
585 storeInfo.iTotalEntries=iPhbkInfo.iTotalEntries; |
|
586 storeInfo.iName=iPhbkInfo.iName; |
|
587 storeInfo.iCaps=iPhbkInfo.iCaps; |
|
588 |
|
589 if (storeInfo.ExtensionId()==RMobilePhoneStore::KETelMobilePhonebookStoreV1) |
|
590 { |
|
591 RMobilePhoneBookStore::TMobilePhoneBookInfoV1Pckg* phbkPckg |
|
592 = reinterpret_cast<RMobilePhoneBookStore::TMobilePhoneBookInfoV1Pckg*>(iInfoPckg); |
|
593 RMobilePhoneBookStore::TMobilePhoneBookInfoV1& phbkInfo = (*phbkPckg)(); |
|
594 phbkInfo.iMaxNumLength=iPhbkInfo.iMaxNumLength; |
|
595 phbkInfo.iMaxTextLength=iPhbkInfo.iMaxTextLength; |
|
596 phbkInfo.iLocation=RMobilePhoneBookStore::ELocationUnknown; // could change this later! |
|
597 } |
|
598 |
|
599 CATCommands::Complete(aError,aSource); |
|
600 iTelObject->ReqCompleted(iReqHandle,aError); |
|
601 } |
|
602 } |
|
603 else |
|
604 { |
|
605 // There was an error or the request was cancelled |
|
606 iIo->WriteAndTimerCancel(this); |
|
607 iIo->RemoveExpectStrings(this); |
|
608 iState=EIdle; |
|
609 |
|
610 CATCommands::Complete(aError,aSource); |
|
611 if (iReqHandle) |
|
612 iTelObject->ReqCompleted(iReqHandle,aError); |
|
613 } |
|
614 } |